{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
module Network.WebexTeams
(
WebexTeamsFilter
, WebexTeamsListItem
, ToResponse
, Authorization (..)
, CiscoSparkRequest (..)
, WebexTeamsRequest (..)
, Timestamp (..)
, ErrorCode (..)
, ErrorTitle (..)
, Errors (..)
, Person (..)
, PersonId (..)
, Email (..)
, DisplayName (..)
, NickName (..)
, FirstName (..)
, LastName (..)
, AvatarUrl (..)
, Timezone (..)
, PersonStatus (..)
, PersonType (..)
, PersonList (..)
, PersonFilter (..)
, CreatePerson (..)
, UpdatePerson (..)
, Room (..)
, RoomId (..)
, RoomTitle (..)
, RoomType (..)
, SipAddr (..)
, RoomList (..)
, RoomFilter (..)
, RoomFilterSortBy (..)
, CreateRoom (..)
, UpdateRoom (..)
, Membership (..)
, MembershipId (..)
, MembershipList (..)
, MembershipFilter (..)
, CreateMembership (..)
, UpdateMembership (..)
, Message (..)
, MessageId (..)
, MessageText (..)
, MessageHtml (..)
, MessageMarkdown (..)
, FileUrl (..)
, MessageList (..)
, MessageFilter (..)
, MentionedPeople (..)
, CreateMessage (..)
, TeamName (..)
, TeamId (..)
, Team (..)
, TeamList (..)
, CreateTeam (..)
, UpdateTeam (..)
, TeamMembership (..)
, TeamMembershipId (..)
, TeamMembershipList (..)
, TeamMembershipFilter (..)
, CreateTeamMembership (..)
, UpdateTeamMembership (..)
, Organization (..)
, OrganizationId (..)
, OrganizationDisplayName (..)
, OrganizationList (..)
, License (..)
, LicenseId (..)
, LicenseName (..)
, LicenseUnit (..)
, LicenseList (..)
, LicenseFilter (..)
, Role (..)
, RoleId (..)
, RoleName (..)
, RoleList (..)
, getDetail
, getDetailEither
, ListReader
, getListWithFilter
, getTeamList
, getOrganizationList
, getRoleList
, streamEntityWithFilter
, streamTeamList
, streamOrganizationList
, streamRoleList
, createEntity
, createEntityEither
, updateEntity
, updateEntityEither
, defaultMessageFilter
, defaultTeamMembershipFilter
, deleteRoom
, deleteMembership
, deleteMessage
, deleteTeam
, deleteTeamMembership
) where
import Conduit (ConduitT, yieldMany)
import Control.Monad.IO.Class (MonadIO, liftIO)
import Data.Aeson (FromJSON, ToJSON)
import Data.ByteString (ByteString)
import Data.ByteString.Char8 as C8 (unpack)
import Data.Default (Default (def))
import Data.IORef (IORef, newIORef, readIORef,
writeIORef)
import Data.Maybe (catMaybes, maybeToList)
import Data.Monoid ((<>))
import Data.Text (Text)
import Data.Text.Encoding (encodeUtf8)
import Network.HTTP.Simple
import Network.URI (URIAuth (..))
import Network.WebexTeams.Internal
import Network.WebexTeams.Types
newtype Authorization = Authorization ByteString deriving (Eq, Show)
data WebexTeamsRequest = WebexTeamsRequest
{ webexTeamsRequestRequest :: Request
, webexTeamsRequestScheme :: String
, webexTeamsRequestAuthority :: URIAuth
} deriving (Show)
type CiscoSparkRequest = WebexTeamsRequest
webexTeamsBaseRequest :: Request
webexTeamsBaseRequest
= addRequestHeader "Content-Type" "application/json; charset=utf-8"
$ setRequestPort 443
$ setRequestHost "api.ciscospark.com"
$ setRequestSecure True
$ defaultRequest
instance Default WebexTeamsRequest where
def = WebexTeamsRequest webexTeamsBaseRequest "https:" $ URIAuth "" "api.ciscospark.com" ""
addAuthorizationHeader :: Authorization -> Request -> Request
addAuthorizationHeader (Authorization auth) = addRequestHeader "Authorization" ("Bearer " <> auth)
makeCommonListReq
:: WebexTeamsRequest
-> ByteString
-> WebexTeamsRequest
makeCommonListReq base@WebexTeamsRequest { webexTeamsRequestRequest = req } path
= base { webexTeamsRequestRequest = setRequestPath ("/v1/" <> path) $ setRequestMethod "GET" req }
streamList :: (MonadIO m, WebexTeamsListItem i) => Authorization -> WebexTeamsRequest -> ConduitT () i m ()
streamList auth (WebexTeamsRequest req scheme uriAuth) = do
res <- httpJSON $ addAuthorizationHeader auth req
yieldMany . unwrap $ getResponseBody res
streamListLoop auth res scheme uriAuth
streamListLoop :: (MonadIO m, FromJSON a, WebexTeamsListItem i) => Authorization -> Response a -> String -> URIAuth -> ConduitT () i m ()
streamListLoop auth res scheme uriAuth
= case getNextUrl res >>= validateUrl scheme uriAuth >>= (\url -> parseRequest $ "GET " <> C8.unpack url) of
Nothing -> pure ()
Just nextReq -> do
nextRes <- httpJSON $ addAuthorizationHeader auth nextReq
yieldMany . unwrap $ getResponseBody nextRes
streamListLoop auth nextRes scheme uriAuth
{-# DEPRECATED streamEntityWithFilter "Use getListWithFilter or streamListWithFilter of webex-teams-conduit" #-}
streamEntityWithFilter :: (MonadIO m, WebexTeamsFilter filter, WebexTeamsListItem (ToResponse filter))
=> Authorization
-> WebexTeamsRequest
-> filter
-> ConduitT () (ToResponse filter) m ()
streamEntityWithFilter auth base param =
streamList auth $ setQeuryString $ makeCommonListReq base (apiPath param)
where
setQeuryString comm@WebexTeamsRequest { webexTeamsRequestRequest = req }
= comm { webexTeamsRequestRequest = setRequestQueryString (toFilterList param) req }
{-# DEPRECATED streamTeamList "Use getTeamList or streamTeamList of webex-teams-conduit" #-}
streamTeamList :: MonadIO m => Authorization -> WebexTeamsRequest -> ConduitT () Team m ()
streamTeamList auth base = streamList auth $ makeCommonListReq base teamsPath
{-# DEPRECATED streamOrganizationList "Use getOrganizationList or streamOrganizationList of webex-teams-conduit" #-}
streamOrganizationList :: MonadIO m => Authorization -> WebexTeamsRequest -> ConduitT () Organization m ()
streamOrganizationList auth base = streamList auth $ makeCommonListReq base organizationsPath
{-# DEPRECATED streamRoleList "Use getRoleList or streamRoleList of webex-teams-conduit" #-}
streamRoleList :: MonadIO m => Authorization -> WebexTeamsRequest -> ConduitT () Role m ()
streamRoleList auth base = streamList auth $ makeCommonListReq base rolesPath
type ListReader a = IO [a]
getList :: (MonadIO m, WebexTeamsListItem i) => Authorization -> WebexTeamsRequest -> m (ListReader i)
getList auth wxReq = liftIO $ listReader <$> newIORef (Just wxReq)
where
listReader :: WebexTeamsListItem i => IORef (Maybe WebexTeamsRequest) -> ListReader i
listReader wxReqRef = do
maybeReq <- readIORef wxReqRef
case maybeReq of
Nothing -> pure []
Just (WebexTeamsRequest req scheme uriAuth) -> do
res <- httpJSON $ addAuthorizationHeader auth req
writeIORef wxReqRef $ do
maybeUrl <- getNextUrl res
maybeValidUrl <-validateUrl scheme uriAuth maybeUrl
maybeNextReq <- parseRequest $ "GET " <> C8.unpack maybeValidUrl
pure (WebexTeamsRequest maybeNextReq scheme uriAuth)
rr <- readIORef wxReqRef
pure . unwrap $ getResponseBody res
getListWithFilter :: (MonadIO m, WebexTeamsFilter filter, WebexTeamsListItem (ToResponse filter))
=> Authorization
-> WebexTeamsRequest
-> filter
-> m (ListReader (ToResponse filter))
getListWithFilter auth base param =
getList auth $ setQeuryString $ makeCommonListReq base (apiPath param)
where
setQeuryString comm@WebexTeamsRequest { webexTeamsRequestRequest = req }
= comm { webexTeamsRequestRequest = setRequestQueryString (toFilterList param) req }
getTeamList :: MonadIO m => Authorization -> WebexTeamsRequest -> m (ListReader Team)
getTeamList auth base = getList auth $ makeCommonListReq base teamsPath
getOrganizationList :: MonadIO m => Authorization -> WebexTeamsRequest -> m (ListReader Organization)
getOrganizationList auth base = getList auth $ makeCommonListReq base organizationsPath
getRoleList :: MonadIO m => Authorization -> WebexTeamsRequest -> m (ListReader Role)
getRoleList auth base = getList auth $ makeCommonListReq base rolesPath
makeCommonDetailReq
:: WebexTeamsRequest
-> Authorization
-> ByteString
-> Text
-> Request
makeCommonDetailReq (WebexTeamsRequest base _ _) auth path idStr
= setRequestPath ("/v1/" <> path <> "/" <> encodeUtf8 idStr)
$ setRequestMethod "GET"
$ addAuthorizationHeader auth
$ base
getDetail :: (MonadIO m, WebexTeamsDetail key)
=> Authorization
-> WebexTeamsRequest
-> key
-> m (Response (ToResponse key))
getDetail auth base entityId = httpJSON $ makeCommonDetailReq base auth (apiPath entityId) (toIdStr entityId)
getDetailEither :: (MonadIO m, WebexTeamsDetail key)
=> Authorization
-> WebexTeamsRequest
-> key
-> m (Response (Either JSONException (ToResponse key)))
getDetailEither auth base entityId = httpJSONEither $ makeCommonDetailReq base auth (apiPath entityId) (toIdStr entityId)
makeCommonCreateReq :: ToJSON a => WebexTeamsRequest -> Authorization -> ByteString -> a -> Request
makeCommonCreateReq (WebexTeamsRequest base _ _) auth path body
= setRequestBodyJSON body
$ setRequestPath ("/v1/" <> path)
$ setRequestMethod "POST"
$ addAuthorizationHeader auth
$ base
createEntity :: (MonadIO m, WebexTeamsCreate createParams)
=> Authorization
-> WebexTeamsRequest
-> createParams
-> m (Response (ToResponse createParams))
createEntity auth base param = httpJSON $ makeCommonCreateReq base auth (apiPath param) param
createEntityEither :: (MonadIO m, WebexTeamsCreate createParams)
=> Authorization
-> WebexTeamsRequest
-> createParams
-> m (Response (Either JSONException (ToResponse createParams)))
createEntityEither auth base param = httpJSONEither $ makeCommonCreateReq base auth (apiPath param) param
makeCommonUpdateReq :: ToJSON a => WebexTeamsRequest -> Authorization -> ByteString -> a -> Request
makeCommonUpdateReq (WebexTeamsRequest base _ _) auth path body
= setRequestBodyJSON body
$ setRequestPath ("/v1/" <> path)
$ setRequestMethod "PUT"
$ addAuthorizationHeader auth
$ base
updateEntity :: (MonadIO m, WebexTeamsUpdate updateParams)
=> Authorization
-> WebexTeamsRequest
-> updateParams
-> m (Response (ToResponse updateParams))
updateEntity auth base param = httpJSON $ makeCommonUpdateReq base auth (apiPath param) param
updateEntityEither :: (MonadIO m, WebexTeamsUpdate updateParams)
=> Authorization
-> WebexTeamsRequest
-> updateParams
-> m (Response (Either JSONException (ToResponse updateParams)))
updateEntityEither auth base param = httpJSONEither $ makeCommonUpdateReq base auth (apiPath param) param
makeCommonDeleteReq
:: Authorization
-> Request
-> ByteString
-> Text
-> Request
makeCommonDeleteReq auth base path idStr
= setRequestPath ("/v1/" <> path <> "/" <> encodeUtf8 idStr)
$ setRequestMethod "DELETE"
$ addAuthorizationHeader auth
$ base
deleteEntity :: (MonadIO m, WebexTeamsDetail key)
=> Authorization
-> WebexTeamsRequest
-> key
-> m (Response ())
deleteEntity auth (WebexTeamsRequest base _ _) entityId
= httpNoBody $ makeCommonDeleteReq auth base (apiPath entityId) (toIdStr entityId)
deleteRoom :: MonadIO m
=> Authorization
-> WebexTeamsRequest
-> RoomId
-> m (Response ())
deleteRoom = deleteEntity
deleteMembership :: MonadIO m
=> Authorization
-> WebexTeamsRequest
-> MembershipId
-> m (Response ())
deleteMembership = deleteEntity
deleteMessage :: MonadIO m
=> Authorization
-> WebexTeamsRequest
-> MessageId
-> m (Response ())
deleteMessage = deleteEntity
deleteTeam :: MonadIO m
=> Authorization
-> WebexTeamsRequest
-> TeamId
-> m (Response ())
deleteTeam = deleteEntity
deleteTeamMembership :: MonadIO m
=> Authorization
-> WebexTeamsRequest
-> TeamMembershipId
-> m (Response ())
deleteTeamMembership = deleteEntity