{-# 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 qualified Data.Aeson.KeyMap as KM
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 :: [Char] -> IO URI
mmPath [Char]
str =
  forall e r. Exception e => Maybe r -> e -> IO r
noteE ([Char] -> Maybe URI
parseRelativeReference [Char]
str)
        ([Char] -> URIParseException
URIParseException ([Char]
"mmPath: " forall a. [a] -> [a] -> [a]
++ [Char]
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 :: forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
label Response_String
rsp = do
  Response_String -> IO ()
assertJSONResponse Response_String
rsp

  let value :: Either JSONDecodeException t
value = forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\[Char]
s -> [Char] -> [Char] -> JSONDecodeException
JSONDecodeException ([Char]
"mmGetJSONBody: " forall a. [a] -> [a] -> [a]
++ [Char]
label forall a. [a] -> [a] -> [a]
++ [Char]
": " forall a. [a] -> [a] -> [a]
++ [Char]
s)
                                              (forall a. Response a -> a
rspBody Response_String
rsp))
                   (forall a. FromJSON a => ByteString -> Either [Char] a
eitherDecode ([Char] -> ByteString
BL.pack (forall a. Response a -> a
rspBody Response_String
rsp)))
  let rawVal :: Either JSONDecodeException Value
rawVal = forall (a :: * -> * -> *) b c d.
ArrowChoice a =>
a b c -> a (Either b d) (Either c d)
left (\[Char]
s -> [Char] -> [Char] -> JSONDecodeException
JSONDecodeException ([Char]
"mmGetJSONBody: " forall a. [a] -> [a] -> [a]
++ [Char]
label forall a. [a] -> [a] -> [a]
++ [Char]
": " forall a. [a] -> [a] -> [a]
++ [Char]
s)
                                              (forall a. Response a -> a
rspBody Response_String
rsp))
                   (forall a. FromJSON a => ByteString -> Either [Char] a
eitherDecode ([Char] -> ByteString
BL.pack (forall a. Response a -> a
rspBody Response_String
rsp)))
  forall e r. Exception e => Either e r -> IO r
hoistE forall a b. (a -> b) -> a -> b
$ do
    Value
x <- Either JSONDecodeException Value
rawVal
    t
y <- Either JSONDecodeException t
value
    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 :: forall t.
ToJSON t =>
ConnectionData -> URI -> t -> IO Response_String
mmUnauthenticatedHTTPPost ConnectionData
cd URI
path t
json = do
  Result Response_String
rsp <- forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let content :: ByteString
content       = ByteString -> ByteString
BL.toStrict (forall a. ToJSON a => a -> ByteString
encode t
json)
        contentLength :: Int
contentLength = ByteString -> Int
B.length ByteString
content
        request :: Request [Char]
request       = Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
POST
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrHost          (Text -> [Char]
T.unpack forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrUserAgent     [Char]
defaultUserAgent
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrContentType   [Char]
"application/json"
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrContentLength (forall a. Show a => a -> [Char]
show Int
contentLength)
                        ] forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: [Char]
rqBody    = ByteString -> [Char]
B.unpack ByteString
content
          }
    forall s.
Stream s =>
s -> Request [Char] -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request [Char]
request
  forall e r. Exception e => Either e r -> IO r
hoistE forall a b. (a -> b) -> a -> b
$ 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 :: [Char]
rawPath = [Char]
"/api/v3/users/login"
  URI
path <- [Char] -> IO URI
mmPath [Char]
rawPath
  ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
"mmLogin" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
GET [Char]
rawPath (forall a. a -> Maybe a
Just (forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ Login
login { password :: Text
password = Text
"<elided>" }))
  Response_String
rsp  <- forall t.
ToJSON t =>
ConnectionData -> URI -> t -> IO Response_String
mmUnauthenticatedHTTPPost ConnectionData
cd URI
path Login
login
  if (forall a. Response a -> ResponseCode
rspCode Response_String
rsp forall a. Eq a => a -> a -> Bool
/= (Int
2,Int
0,Int
0))
    then do
        let eMsg :: [Char]
eMsg = [Char]
"Server returned unexpected " forall a. Semigroup a => a -> a -> a
<> ResponseCode -> [Char]
showRespCode (forall a. Response a -> ResponseCode
rspCode Response_String
rsp) forall a. Semigroup a => a -> a -> a
<> [Char]
" response"
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ [Char] -> LoginFailureException
LoginFailureException [Char]
eMsg
    else do
      [Char]
token <- Response_String -> HeaderName -> IO [Char]
mmGetHeader   Response_String
rsp ([Char] -> HeaderName
HdrCustom [Char]
"Token")
      (Value
raw, User
value) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"User" Response_String
rsp
      ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
"mmLogin" forall a b. (a -> b) -> a -> b
$
        Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
rawPath (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
raw)
      forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right (ConnectionData -> Token -> Session
Session ConnectionData
cd ([Char] -> Token
Token [Char]
token), User
value))

showRespCode :: (Int, Int, Int) -> String
showRespCode :: ResponseCode -> [Char]
showRespCode (Int
a, Int
b, Int
c) = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show 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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetInitialLoad" [Char]
"/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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetTeams" [Char]
"/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 :: [Char]
path = [Char]
"/api/v3/teams/create"
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmCreateTeam" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show TeamsCreate
payload)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri TeamsCreate
payload
  (Value
val, Team
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Team" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmCreateTeam" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 = forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetChannels" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/" (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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetMoreChannels" forall a b. (a -> b) -> a -> b
$
    forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/more/%d/%d"
           (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 = forall t a.
FromJSON t =>
Session -> [Char] -> [Char] -> (t -> IO a) -> IO a
mmWithRequest Session
sess [Char]
"mmGetChannel"
  (forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/"
          (forall x. IsId x => x -> Text
idString TeamId
teamid)
          (forall x. IsId x => x -> Text
idString ChannelId
chanid))
  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 =
    forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetAllChannelDataForUser" forall a b. (a -> b) -> a -> b
$
      forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v4/users/%s/teams/%s/channels/members"
             (forall x. IsId x => x -> Text
idString UserId
userid)
             (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 =
    forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetAllChannelsForUser" forall a b. (a -> b) -> a -> b
$
      forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v4/users/%s/teams/%s/channels"
             (forall x. IsId x => x -> Text
idString UserId
userid)
             (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 = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList forall a b. (a -> b) -> a -> b
$ (\ChannelData
d -> (ChannelData -> ChannelId
channelDataChannelId ChannelData
d, ChannelData
d)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Seq ChannelData
datas
        mkPair :: Channel -> (ChannelId, ChannelWithData)
mkPair Channel
chan = (forall x y. HasId x y => x -> y
getId Channel
chan, Channel -> ChannelData -> ChannelWithData
ChannelWithData Channel
chan forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HM.lookup (forall x y. HasId x y => x -> y
getId Channel
chan) HashMap ChannelId ChannelData
dataMap)

    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList forall a b. (a -> b) -> a -> b
$ Channel -> (ChannelId, ChannelWithData)
mkPair 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 :: [Char]
path    = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/view"
                       (forall x. IsId x => x -> Text
idString TeamId
teamid)
      prev :: [(Text, ChannelId)]
prev    = forall a. Maybe a -> [a]
maybeToList ((Text
"prev_channel_id" :: T.Text,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ChannelId
previd)
      payload :: HashMap Text ChannelId
payload = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList forall a b. (a -> b) -> a -> b
$ [(Text
"channel_id" :: T.Text, ChannelId
chanid)] forall a. [a] -> [a] -> [a]
++ [(Text, ChannelId)]
prev
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmViewChannel" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show HashMap Text ChannelId
payload)
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri HashMap Text ChannelId
payload
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmViewChannel" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path forall a. Maybe a
Nothing
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/join"
                   (forall x. IsId x => x -> Text
idString TeamId
teamid)
                   (forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmJoinChannel" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path forall a. Maybe a
Nothing
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri (Text
""::T.Text)
  (Value
val, (Channel
_::Channel)) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Channel" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmJoinChannel" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/leave"
                   (forall x. IsId x => x -> Text
idString TeamId
teamid)
                   (forall x. IsId x => x -> Text
idString ChannelId
chanid)
      payload :: HashMap Text ChannelId
payload = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(Text
"id" :: T.Text, ChannelId
chanid)]
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmLeaveChannel" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show HashMap Text ChannelId
payload)
  Response_String
rsp <- 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)) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Channel name/ID map" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmCreateDirect" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetPosts" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/page/%d/%d"
         (forall x. IsId x => x -> Text
idString TeamId
teamid)
         (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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetPostsSince" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/since/%d"
         (forall x. IsId x => x -> Text
idString TeamId
teamid)
         (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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/%s/get"
             (forall x. IsId x => x -> Text
idString TeamId
teamid)
             (forall x. IsId x => x -> Text
idString ChannelId
chanid)
             (forall x. IsId x => x -> Text
idString PostId
postid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Response_String
rsp <- Session -> URI -> IO Response_String
mmRequest Session
sess URI
uri
  (Value
raw, Posts
json) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Posts" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmGetPost" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
raw)
  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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetPosts" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/%s/after/%d/%d"
         (forall x. IsId x => x -> Text
idString TeamId
teamid)
         (forall x. IsId x => x -> Text
idString ChannelId
chanid)
         (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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetPosts" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/%s/before/%d/%d"
         (forall x. IsId x => x -> Text
idString TeamId
teamid)
         (forall x. IsId x => x -> Text
idString ChannelId
chanid)
         (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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v4/teams/%s/posts/search" forall a b. (a -> b) -> a -> b
$ forall x. IsId x => x -> Text
idString TeamId
teamid
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  let req :: SearchPosts
req = Text -> Bool -> SearchPosts
SearchPosts Text
terms Bool
isOrSearch
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmSearchPosts" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show SearchPosts
req)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri SearchPosts
req
  (Value
raw, Posts
value) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"SearchPostsResult" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmSearchPosts" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
raw)
  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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetFileInfo" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/files/%s/get_info" (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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v4/files/%s" (forall x. IsId x => x -> Text
idString FileId
fileId)
  URI
uri  <- [Char] -> IO URI
mmPath [Char]
path
  ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
"mmGetFile" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
GET [Char]
path forall a. Maybe a
Nothing
  Response_String
rsp  <- Session -> URI -> IO Response_String
mmRequest Session
sess URI
uri
  forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> ByteString
B.pack (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 = forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetUser" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/users/%s/get" (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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetUsers" forall a b. (a -> b) -> a -> b
$
    forall r. PrintfType r => [Char] -> r
printf [Char]
"/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 = forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetTeamMembers" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/members/%s" (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 = forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetChannelMembers" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/users/%d/%d"
         (forall x. IsId x => x -> Text
idString TeamId
teamid)
         (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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetProfilesForDMList" forall a b. (a -> b) -> a -> b
$
    forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/users/profiles_for_dm_list/%s" (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 = forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetMe" [Char]
"/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 = forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetProfiles" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/users/%d/%d"
         (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 = forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetStatuses" forall a b. (a -> b) -> a -> b
$
  forall r. PrintfType r => [Char] -> r
printf [Char]
"/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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/create_direct" (forall x. IsId x => x -> Text
idString TeamId
teamid)
      payload :: HashMap Text UserId
payload = forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(Text
"user_id" :: T.Text, UserId
userid)]
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmCreateDirect" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show HashMap Text UserId
payload)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri HashMap Text UserId
payload
  (Value
val, Channel
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Channel" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmCreateDirect" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/create" (forall x. IsId x => x -> Text
idString TeamId
teamid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmCreateChannel" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show MinChannel
payload)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri MinChannel
payload
  (Value
val, Channel
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Channel" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmCreateChannel" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/delete"
               (forall x. IsId x => x -> Text
idString TeamId
teamid) (forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmDeleteChannel" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path forall a. Maybe a
Nothing
  Response_String
_ <- Session -> URI -> ByteString -> IO Response_String
mmRawPOST Session
sess URI
uri ByteString
""
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmDeleteChannel" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path forall a. Maybe a
Nothing
  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 :: [Char]
path   = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/%s/delete"
                      (forall x. IsId x => x -> Text
idString TeamId
teamid)
                      (forall x. IsId x => x -> Text
idString ChannelId
chanid)
                      (forall x. IsId x => x -> Text
idString PostId
postid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmDeletePost" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path forall a. Maybe a
Nothing
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri ([]::[String])
  (Value
_, Value
_::Value) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Post" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmDeletePost" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path forall a. Maybe a
Nothing
  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 :: [Char]
path   = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/update"
                      (forall x. IsId x => x -> Text
idString TeamId
teamid)
                      (forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmUpdatePost" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just (forall a. Show a => a -> [Char]
show Post
post))
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Post
post
  (Value
val, Post
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Post" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmUpdatePost" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path   = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/create"
                      (forall x. IsId x => x -> Text
idString TeamId
teamid)
                      (forall x. IsId x => x -> Text
idString ChannelId
chanid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmPost" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show PendingPost
post)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri PendingPost
post
  (Value
val, Post
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Post" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmPost" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetConfig" [Char]
"/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 =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetClientConfig" [Char]
"/api/v4/config/client?format=old"

mmSaveConfig :: Session
             -> Value
             -> IO ()
mmSaveConfig :: Session -> Value -> IO ()
mmSaveConfig Session
sess Value
config = do
  let path :: [Char]
path = [Char]
"/api/v3/admin/save_config"
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmSaveConfig" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
config)
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Value
config
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmSaveConfig" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path forall a. Maybe a
Nothing
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/add"
                    (forall x. IsId x => x -> Text
idString TeamId
teamid)
                    (forall x. IsId x => x -> Text
idString ChannelId
chanId)
      req :: Value
req = [Pair] -> Value
object [Key
"user_id" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UserId
uId]
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmChannelAddUser" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
req)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Value
req
  (Value
val, ChannelData
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"ChannelData" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmChannelAddUser" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/add_user_to_team"
                    (forall x. IsId x => x -> Text
idString TeamId
teamid)
      req :: Value
req  = [Pair] -> Value
object [Key
"user_id" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UserId
uId]
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmTeamAddUser" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
req)
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Value
req
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmTeamAddUSer" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path forall a. Maybe a
Nothing
  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 :: [Char]
path   = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/commands/execute"
                      (forall x. IsId x => x -> Text
idString TeamId
teamid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmExecute" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show MinCommand
command)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri MinCommand
command
  (Value
val, CommandResponse
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Value" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmExecute" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path = [Char]
"/api/v3/users/create"
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
"mmUsersCreate" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show UsersCreate
usersCreate)
  Response_String
rsp <- forall t.
ToJSON t =>
ConnectionData -> URI -> t -> IO Response_String
mmUnauthenticatedHTTPPost ConnectionData
cd URI
uri UsersCreate
usersCreate
  (Value
val, User
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"User" Response_String
rsp
  ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
"mmUsersCreate" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path = [Char]
"/api/v3/users/create"
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmUsersCreateWithToken" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show UsersCreate
usersCreate)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri UsersCreate
usersCreate
  (Value
val, User
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"User" Response_String
rsp
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmUsersCreateWithToken" forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
val)
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/%s/posts/%s/reactions"
                    (forall x. IsId x => x -> Text
idString TeamId
tId)
                    (forall x. IsId x => x -> Text
idString ChannelId
cId)
                    (forall x. IsId x => x -> Text
idString PostId
pId)
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetReactionsForPost" [Char]
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 <- [Char] -> IO URI
mmPath forall a b. (a -> b) -> a -> b
$ forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v4/users/%s/preferences" (forall x. IsId x => x -> Text
idString UserId
uId)
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPUT Session
sess URI
uri Seq Preference
prefs
  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 <- [Char] -> IO URI
mmPath [Char]
"/api/v3/preferences/save"
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Seq Preference
pref
  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 <- [Char] -> IO URI
mmPath [Char]
"/api/v3/preferences/delete"
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri Seq Preference
pref
  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
          { flaggedPostUserId :: UserId
flaggedPostUserId = UserId
uId
          , flaggedPostId :: PostId
flaggedPostId     = PostId
pId
          , flaggedPostStatus :: Bool
flaggedPostStatus = Bool
True
          }
  let rawPath :: [Char]
rawPath = [Char]
"/api/v3/preferences/save"
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmFlagPost" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
rawPath (forall a. a -> Maybe a
Just (forall a. Show a => a -> [Char]
show [FlaggedPost
flaggedPost]))
  URI
uri <- [Char] -> IO URI
mmPath [Char]
rawPath
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri (forall a. a -> Seq a
Seq.singleton FlaggedPost
flaggedPost)
  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
          { flaggedPostUserId :: UserId
flaggedPostUserId = UserId
uId
          , flaggedPostId :: PostId
flaggedPostId     = PostId
pId
          , flaggedPostStatus :: Bool
flaggedPostStatus = Bool
True
          }
  let rawPath :: [Char]
rawPath = [Char]
"/api/v3/preferences/delete"
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmUnflagPost" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
rawPath (forall a. a -> Maybe a
Just (forall a. Show a => a -> [Char]
show [FlaggedPost
flaggedPost]))
  URI
uri <- [Char] -> IO URI
mmPath [Char]
rawPath
  Response_String
_ <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri (forall a. a -> Seq a
Seq.singleton FlaggedPost
flaggedPost)
  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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v4/users/%s/posts/flagged" (forall x. IsId x => x -> Text
idString UserId
uId)
  in forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmGetFlaggedPosts" [Char]
path

mmGetMyPreferences :: Session
                -> IO (Seq.Seq Preference)
mmGetMyPreferences :: Session -> IO (Seq Preference)
mmGetMyPreferences Session
sess =
  forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
"mmMyPreferences" [Char]
"/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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v4/channels/%s/members/%s" (forall x. IsId x => x -> Text
idString ChannelId
cId) (forall x. IsId x => x -> Text
idString UserId
uId)
  in Session -> URI -> IO ()
mmDeleteRequest Session
sess forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Char] -> IO URI
mmPath [Char]
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 :: [Char]
path = [Char]
"/api/v4/channels/group"
      fnname :: [Char]
fnname = [Char]
"mmCreateGroupChannel"
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
fnname forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show [UserId]
uIds)
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri [UserId]
uIds
  (Value
raw, Channel
json) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
fnname Response_String
rsp
  ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
fnname forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
raw)
  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 <- forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let request :: Request [Char]
request = Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
DELETE
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrAuthorization ([Char]
"Bearer " forall a. [a] -> [a] -> [a]
++ Token -> [Char]
getTokenString Token
token)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrHost          (Text -> [Char]
T.unpack forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrUserAgent     [Char]
defaultUserAgent
                        ] forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: [Char]
rqBody    = [Char]
""
          }
    forall s.
Stream s =>
s -> Request [Char] -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request [Char]
request
  Response_String
rsp <- forall e r. Exception e => Either e r -> IO r
hoistE forall a b. (a -> b) -> a -> b
$ 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 <- forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let request :: Request [Char]
request = Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
GET
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrAuthorization ([Char]
"Bearer " forall a. [a] -> [a] -> [a]
++ Token -> [Char]
getTokenString Token
token)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrHost          (Text -> [Char]
T.unpack forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrUserAgent     [Char]
defaultUserAgent
                        ] forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: [Char]
rqBody    = [Char]
""
          }
    forall s.
Stream s =>
s -> Request [Char] -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request [Char]
request
  Response_String
rsp <- forall e r. Exception e => Either e r -> IO r
hoistE forall a b. (a -> b) -> a -> b
$ 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
  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 :: forall t. FromJSON t => Session -> [Char] -> [Char] -> IO t
mmDoRequest Session
sess [Char]
fnname [Char]
path = forall t a.
FromJSON t =>
Session -> [Char] -> [Char] -> (t -> IO a) -> IO a
mmWithRequest Session
sess [Char]
fnname [Char]
path 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 :: forall t a.
FromJSON t =>
Session -> [Char] -> [Char] -> (t -> IO a) -> IO a
mmWithRequest sess :: Session
sess@(Session ConnectionData
cd Token
_) [Char]
fnname [Char]
path t -> IO a
action = do
  URI
uri  <- [Char] -> IO URI
mmPath [Char]
path
  ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
fnname forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
GET [Char]
path forall a. Maybe a
Nothing
  Response_String
rsp  <- Session -> URI -> IO Response_String
mmRequest Session
sess URI
uri
  (Value
raw,t
json) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
fnname Response_String
rsp
  ConnectionData -> [Char] -> LogEventType -> IO ()
runLogger ConnectionData
cd [Char]
fnname forall a b. (a -> b) -> a -> b
$
    Int -> [Char] -> Maybe [Char] -> LogEventType
HttpResponse Int
200 [Char]
path (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show Value
raw)
  t -> IO a
action t
json

mmPOST :: ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST :: forall t. ToJSON t => 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 (forall a. ToJSON a => a -> ByteString
encode t
json))

mmPUT :: ToJSON t => Session -> URI -> t -> IO Response_String
mmPUT :: forall t. ToJSON t => 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 (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 :: [Char]
path = forall r. PrintfType r => [Char] -> r
printf [Char]
"/api/v3/teams/%s/channels/update_header"
                    (forall x. IsId x => x -> Text
idString TeamId
teamid)
  URI
uri <- [Char] -> IO URI
mmPath [Char]
path
  let req :: SetChannelHeader
req = ChannelId -> Text -> SetChannelHeader
SetChannelHeader ChannelId
chanid Text
header
  Session -> [Char] -> LogEventType -> IO ()
runLoggerS Session
sess [Char]
"mmSetChannelHeader" forall a b. (a -> b) -> a -> b
$
    RequestMethod -> [Char] -> Maybe [Char] -> LogEventType
HttpRequest RequestMethod
POST [Char]
path (forall a. a -> Maybe a
Just (forall a. Show a => a -> [Char]
show SetChannelHeader
req))
  Response_String
rsp <- forall t. ToJSON t => Session -> URI -> t -> IO Response_String
mmPOST Session
sess URI
uri SetChannelHeader
req
  (Value
_, Channel
r) <- forall t. FromJSON t => [Char] -> Response_String -> IO (Value, t)
mmGetJSONBody [Char]
"Channel" Response_String
rsp
  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 <- forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let contentLength :: Int
contentLength = ByteString -> Int
B.length ByteString
content
        request :: Request [Char]
request       = Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
POST
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrAuthorization ([Char]
"Bearer " forall a. [a] -> [a] -> [a]
++ Token -> [Char]
getTokenString Token
token)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrHost          (Text -> [Char]
T.unpack forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrUserAgent     [Char]
defaultUserAgent
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrContentType   [Char]
"application/json"
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrContentLength (forall a. Show a => a -> [Char]
show Int
contentLength)
                        ] forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: [Char]
rqBody    = ByteString -> [Char]
B.unpack ByteString
content
          }
    forall s.
Stream s =>
s -> Request [Char] -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request [Char]
request
  Response_String
rsp <- forall e r. Exception e => Either e r -> IO r
hoistE forall a b. (a -> b) -> a -> b
$ 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
  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 <- forall a. ConnectionData -> (MMConn -> IO a) -> IO a
withConnection ConnectionData
cd forall a b. (a -> b) -> a -> b
$ \MMConn
con -> do
    let contentLength :: Int
contentLength = ByteString -> Int
B.length ByteString
content
        request :: Request [Char]
request       = Request
          { rqURI :: URI
rqURI     = URI
path
          , rqMethod :: RequestMethod
rqMethod  = RequestMethod
PUT
          , rqHeaders :: [Header]
rqHeaders = [ HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrAuthorization ([Char]
"Bearer " forall a. [a] -> [a] -> [a]
++ Token -> [Char]
getTokenString Token
token)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrHost          (Text -> [Char]
T.unpack forall a b. (a -> b) -> a -> b
$ ConnectionData -> Text
cdHostname ConnectionData
cd)
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrUserAgent     [Char]
defaultUserAgent
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrContentType   [Char]
"application/json"
                        , HeaderName -> [Char] -> Header
mkHeader HeaderName
HdrContentLength (forall a. Show a => a -> [Char]
show Int
contentLength)
                        ] forall a. [a] -> [a] -> [a]
++ AutoClose -> [Header]
autoCloseToHeader (ConnectionData -> AutoClose
cdAutoClose ConnectionData
cd)
          , rqBody :: [Char]
rqBody    = ByteString -> [Char]
B.unpack ByteString
content
          }
    forall s.
Stream s =>
s -> Request [Char] -> IO (Result Response_String)
simpleHTTP_ MMConn
con Request [Char]
request
  Response_String
rsp <- forall e r. Exception e => Either e r -> IO r
hoistE forall a b. (a -> b) -> a -> b
$ 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
  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 forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall {a} {a} {c}. (Eq a, Eq a, Num a, Num a) => (a, a, c) -> Bool
is20x forall a b. (a -> b) -> a -> b
$ forall a. Response a -> ResponseCode
rspCode Response_String
rsp) forall a b. (a -> b) -> a -> b
$
        let httpExc :: HTTPResponseException
httpExc = [Char] -> HTTPResponseException
HTTPResponseException forall a b. (a -> b) -> a -> b
$ [Char]
"mmRequest: expected 200 response, got " forall a. Semigroup a => a -> a -> a
<>
                                              (forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ forall a. Response a -> ResponseCode
rspCode Response_String
rsp)
        in case forall a. FromJSON a => ByteString -> Either [Char] a
eitherDecode forall a b. (a -> b) -> a -> b
$ [Char] -> ByteString
BL.pack forall a b. (a -> b) -> a -> b
$ forall a. Response a -> a
rspBody Response_String
rsp of
            Right (Object Object
o) ->
                case forall v. Key -> KeyMap v -> Maybe v
KM.lookup Key
"message" Object
o of
                    Just (String Text
msg) ->
                        let newMsg :: Text
newMsg = ([Char] -> Text
T.pack forall a b. (a -> b) -> a -> b
$ [Char]
"Error requesting " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> [Char]
show URI
path forall a. Semigroup a => a -> a -> a
<> [Char]
": ") forall a. Semigroup a => a -> a -> a
<> Text
msg
                        in forall e a. Exception e => e -> IO a
throwIO forall a b. (a -> b) -> a -> b
$ Text -> MattermostServerError
MattermostServerError Text
newMsg
                    Maybe Value
_ -> forall e a. Exception e => e -> IO a
throwIO forall a b. (a -> b) -> a -> b
$ HTTPResponseException
httpExc
            Either [Char] Value
_ -> forall e a. Exception e => e -> IO a
throwIO 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