{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns        #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE RecordWildCards       #-}
{-# LANGUAGE ScopedTypeVariables   #-}
{-# LANGUAGE TypeApplications      #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE TypeOperators         #-}

-- |
-- Module      : Line.Bot.Client
-- Copyright   : (c) Alexandre Moreno, 2019-2021
-- License     : BSD-3-Clause
-- Maintainer  : alexmorenocano@gmail.com
-- Stability   : experimental

module Line.Bot.Client
  ( Line
  , runLine
  , withLine
  , withLineEnv
  -- ** Profile
  , getProfile
  -- ** Group
  , getGroupMemberProfile
  , leaveGroup
  , getGroupMemberUserIds
  -- ** Room
  , getRoomMemberProfile
  , leaveRoom
  , getRoomMemberUserIds
  -- ** Message
  , replyMessage
  , pushMessage
  , multicastMessage
  , broadcastMessage
  , getContent
  , getContentS
  , getPushMessageCount
  , getReplyMessageCount
  , getMulticastMessageCount
  , getBroadcastMessageCount
  , getMessageQuota
  -- ** Account Link
  , issueLinkToken
  -- ** OAuth
  , issueChannelToken
  , revokeChannelToken
  -- ** Rich menus
  , createRichMenu
  , deleteRichMenu
  , getRichMenu
  , uploadRichMenuImageJpg
  , getRichMenuList
  , setDefaultRichMenu
  )
where

import           Control.DeepSeq             (NFData)
import           Control.Monad.Reader
import           Data.ByteString             (ByteString)
import qualified Data.ByteString.Lazy        as LB
import           Data.Functor
import           Data.Proxy
import           Data.Time.Calendar          (Day)
import           Data.Text                   (Text, pack)
import           GHC.TypeLits                (Symbol)
import           Line.Bot.Internal.Endpoints
import           Line.Bot.Types
import           Network.HTTP.Client         (newManager)
import           Network.HTTP.Client.TLS     (tlsManagerSettings)
import           Servant.API
import           Servant.Client.Streaming
import           Paths_line_bot_sdk          (version)
import           Data.Version                (showVersion)

defaultEndpoint :: BaseUrl
defaultEndpoint :: BaseUrl
defaultEndpoint = Scheme -> String -> Int -> String -> BaseUrl
BaseUrl Scheme
Https String
"api.line.me" Int
443 String
""

blobEndpoint :: BaseUrl
blobEndpoint :: BaseUrl
blobEndpoint = Scheme -> String -> Int -> String -> BaseUrl
BaseUrl Scheme
Https String
"api-data.line.me" Int
443 String
""

userAgent :: Text
userAgent :: Text
userAgent = Text
"line-bot-sdk-haskell/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
pack (Version -> String
showVersion Version
version)

-- | @Line@ is the monad in which bot requests run. Contains the
-- OAuth access token for a channel
type Line = ReaderT ChannelToken ClientM

-- | Perform a request using LINE 'ClientEnv'
--
-- > withLineEnv $ \env -> runClientM comp env
withLineEnv :: (ClientEnv -> IO a) -> IO a
withLineEnv :: (ClientEnv -> IO a) -> IO a
withLineEnv ClientEnv -> IO a
app = do
  Manager
manager <- ManagerSettings -> IO Manager
newManager ManagerSettings
tlsManagerSettings
  ClientEnv -> IO a
app (ClientEnv -> IO a) -> ClientEnv -> IO a
forall a b. (a -> b) -> a -> b
$ Manager -> BaseUrl -> ClientEnv
mkClientEnv Manager
manager BaseUrl
defaultEndpoint

runLine' :: NFData a => ClientM a -> IO (Either ClientError a)
runLine' :: ClientM a -> IO (Either ClientError a)
runLine' ClientM a
comp = (ClientEnv -> IO (Either ClientError a))
-> IO (Either ClientError a)
forall a. (ClientEnv -> IO a) -> IO a
withLineEnv ((ClientEnv -> IO (Either ClientError a))
 -> IO (Either ClientError a))
-> (ClientEnv -> IO (Either ClientError a))
-> IO (Either ClientError a)
forall a b. (a -> b) -> a -> b
$ \ClientEnv
env -> ClientM a -> ClientEnv -> IO (Either ClientError a)
forall a.
NFData a =>
ClientM a -> ClientEnv -> IO (Either ClientError a)
runClientM ClientM a
comp ClientEnv
env

-- | Executes a request in the LINE plaform with the given 'ChannelToken'
runLine :: NFData a => Line a -> ChannelToken -> IO (Either ClientError a)
runLine :: Line a -> ChannelToken -> IO (Either ClientError a)
runLine Line a
comp = ClientM a -> IO (Either ClientError a)
forall a. NFData a => ClientM a -> IO (Either ClientError a)
runLine' (ClientM a -> IO (Either ClientError a))
-> (ChannelToken -> ClientM a)
-> ChannelToken
-> IO (Either ClientError a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Line a -> ChannelToken -> ClientM a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Line a
comp

withLine' :: ClientM a -> (Either ClientError a -> IO b) -> IO b
withLine' :: ClientM a -> (Either ClientError a -> IO b) -> IO b
withLine' ClientM a
comp Either ClientError a -> IO b
k = (ClientEnv -> IO b) -> IO b
forall a. (ClientEnv -> IO a) -> IO a
withLineEnv ((ClientEnv -> IO b) -> IO b) -> (ClientEnv -> IO b) -> IO b
forall a b. (a -> b) -> a -> b
$ \ClientEnv
env -> ClientM a -> ClientEnv -> (Either ClientError a -> IO b) -> IO b
forall a b.
ClientM a -> ClientEnv -> (Either ClientError a -> IO b) -> IO b
withClientM ClientM a
comp ClientEnv
env Either ClientError a -> IO b
k

-- | Execute a request with a streaming response in the LINE platform
withLine :: Line a -> ChannelToken -> (Either ClientError a -> IO b) -> IO b
withLine :: Line a -> ChannelToken -> (Either ClientError a -> IO b) -> IO b
withLine Line a
comp = ClientM a -> (Either ClientError a -> IO b) -> IO b
forall a b. ClientM a -> (Either ClientError a -> IO b) -> IO b
withLine' (ClientM a -> (Either ClientError a -> IO b) -> IO b)
-> (ChannelToken -> ClientM a)
-> ChannelToken
-> (Either ClientError a -> IO b)
-> IO b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Line a -> ChannelToken -> ClientM a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT Line a
comp

withHost :: BaseUrl -> Line a -> Line a
withHost :: BaseUrl -> Line a -> Line a
withHost BaseUrl
baseUrl = (ClientM a -> ClientM a) -> Line a -> Line a
forall (m :: * -> *) a (n :: * -> *) b r.
(m a -> n b) -> ReaderT r m a -> ReaderT r n b
mapReaderT ((ClientM a -> ClientM a) -> Line a -> Line a)
-> (ClientM a -> ClientM a) -> Line a -> Line a
forall a b. (a -> b) -> a -> b
$ (ClientEnv -> ClientEnv) -> ClientM a -> ClientM a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\ClientEnv
env -> ClientEnv
env { baseUrl :: BaseUrl
baseUrl = BaseUrl
baseUrl })

type family AddHeaders a :: * where
  AddHeaders ((sym :: Symbol) :> last)
    = (sym :: Symbol) :> AddHeaders last
  AddHeaders (first :> last)
    = first :> AddHeaders last
  AddHeaders last
    =  Header' '[Required, Strict] "Authorization" ChannelToken
    :> Header' '[Required, Strict] "User-Agent" Text
    :> last
   
type ClientWithHeaders a = ChannelToken -> Text -> ClientM a

type family EmbedLine a :: * where
  EmbedLine (ClientWithHeaders a) = Line a
  EmbedLine (a -> b) = a -> EmbedLine b

class HasLine a where
  embedLine :: a -> EmbedLine a

instance HasLine (ClientWithHeaders a) where
  embedLine :: ClientWithHeaders a -> EmbedLine (ClientWithHeaders a)
embedLine ClientWithHeaders a
comp = do
    ChannelToken
token <- ReaderT ChannelToken ClientM ChannelToken
forall r (m :: * -> *). MonadReader r m => m r
ask
    ClientM a -> ReaderT ChannelToken ClientM a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ClientM a -> ReaderT ChannelToken ClientM a)
-> ClientM a -> ReaderT ChannelToken ClientM a
forall a b. (a -> b) -> a -> b
$ ClientWithHeaders a
comp ChannelToken
token Text
userAgent

instance HasLine (a -> ClientWithHeaders b) where
  embedLine :: (a -> ClientWithHeaders b) -> EmbedLine (a -> ClientWithHeaders b)
embedLine a -> ClientWithHeaders b
comp = ClientWithHeaders b -> Line b
forall a. HasLine a => a -> EmbedLine a
embedLine (ClientWithHeaders b -> Line b)
-> (a -> ClientWithHeaders b) -> a -> Line b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ClientWithHeaders b
comp

instance HasLine (a -> b -> ClientWithHeaders c) where
  embedLine :: (a -> b -> ClientWithHeaders c)
-> EmbedLine (a -> b -> ClientWithHeaders c)
embedLine a -> b -> ClientWithHeaders c
comp = (b -> ClientWithHeaders c) -> b -> Line c
forall a. HasLine a => a -> EmbedLine a
embedLine ((b -> ClientWithHeaders c) -> b -> Line c)
-> (a -> b -> ClientWithHeaders c) -> a -> b -> Line c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b -> ClientWithHeaders c
comp

line :: (HasLine (Client ClientM (AddHeaders api)), HasClient ClientM (AddHeaders api))
     => Proxy api
     -> EmbedLine (Client ClientM (AddHeaders api))
line :: Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line = Client ClientM (AddHeaders api)
-> EmbedLine (Client ClientM (AddHeaders api))
forall a. HasLine a => a -> EmbedLine a
embedLine (Client ClientM (AddHeaders api)
 -> EmbedLine (Client ClientM (AddHeaders api)))
-> (Proxy api -> Client ClientM (AddHeaders api))
-> Proxy api
-> EmbedLine (Client ClientM (AddHeaders api))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy api -> Client ClientM (AddHeaders api)
forall api.
HasClient ClientM (AddHeaders api) =>
Proxy api -> Client ClientM (AddHeaders api)
clientWithHeaders

clientWithHeaders :: (HasClient ClientM (AddHeaders api))
                  => Proxy api
                  -> Client ClientM (AddHeaders api)
clientWithHeaders :: Proxy api -> Client ClientM (AddHeaders api)
clientWithHeaders (Proxy api
Proxy :: Proxy api) = Proxy (AddHeaders api) -> Client ClientM (AddHeaders api)
forall api.
HasClient ClientM api =>
Proxy api -> Client ClientM api
client (Proxy (AddHeaders api)
forall k (t :: k). Proxy t
Proxy :: Proxy (AddHeaders api))

unfoldMemberUserIds :: (Maybe String -> Line MemberIds) -> Line [Id 'User]
unfoldMemberUserIds :: (Maybe String -> Line MemberIds) -> Line [Id 'User]
unfoldMemberUserIds Maybe String -> Line MemberIds
k = Maybe String -> Line [Id 'User]
go Maybe String
forall a. Maybe a
Nothing where
  go :: Maybe String -> Line [Id 'User]
go Maybe String
tok = do
    MemberIds{Maybe String
$sel:next:MemberIds :: MemberIds -> Maybe String
next :: Maybe String
next, $sel:memberIds:MemberIds :: MemberIds -> [Id 'User]
memberIds = [Id 'User]
a} <- Maybe String -> Line MemberIds
k Maybe String
tok
    [Id 'User]
as <- Line [Id 'User]
-> (String -> Line [Id 'User]) -> Maybe String -> Line [Id 'User]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Id 'User] -> Line [Id 'User]
forall (m :: * -> *) a. Monad m => a -> m a
return []) (\String
_ -> Maybe String -> Line [Id 'User]
go Maybe String
next) Maybe String
next
    [Id 'User] -> Line [Id 'User]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Id 'User] -> Line [Id 'User]) -> [Id 'User] -> Line [Id 'User]
forall a b. (a -> b) -> a -> b
$ [Id 'User]
a [Id 'User] -> [Id 'User] -> [Id 'User]
forall a. [a] -> [a] -> [a]
++ [Id 'User]
as

getProfile :: Id 'User -> Line Profile
getProfile :: Id 'User -> Line Profile
getProfile = Proxy GetProfile
-> EmbedLine (Client ClientM (AddHeaders GetProfile))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetProfile
forall k (t :: k). Proxy t
Proxy @GetProfile)

getGroupMemberProfile :: Id 'Group -> Id 'User -> Line Profile
getGroupMemberProfile :: Id 'Group -> Id 'User -> Line Profile
getGroupMemberProfile = Proxy GetGroupMemberProfile
-> EmbedLine (Client ClientM (AddHeaders GetGroupMemberProfile))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetGroupMemberProfile
forall k (t :: k). Proxy t
Proxy @GetGroupMemberProfile)

leaveGroup :: Id 'Group -> Line NoContent
leaveGroup :: Id 'Group -> Line NoContent
leaveGroup = Proxy LeaveGroup
-> EmbedLine (Client ClientM (AddHeaders LeaveGroup))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy LeaveGroup
forall k (t :: k). Proxy t
Proxy @LeaveGroup)

getGroupMemberUserIds' :: Id 'Group -> Maybe String -> Line MemberIds
getGroupMemberUserIds' :: Id 'Group -> Maybe String -> Line MemberIds
getGroupMemberUserIds' = Proxy GetGroupMemberUserIds
-> EmbedLine (Client ClientM (AddHeaders GetGroupMemberUserIds))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetGroupMemberUserIds
forall k (t :: k). Proxy t
Proxy @GetGroupMemberUserIds)

getGroupMemberUserIds :: Id 'Group -> Line [Id 'User]
getGroupMemberUserIds :: Id 'Group -> Line [Id 'User]
getGroupMemberUserIds = (Maybe String -> Line MemberIds) -> Line [Id 'User]
unfoldMemberUserIds ((Maybe String -> Line MemberIds) -> Line [Id 'User])
-> (Id 'Group -> Maybe String -> Line MemberIds)
-> Id 'Group
-> Line [Id 'User]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Id 'Group -> Maybe String -> Line MemberIds
getGroupMemberUserIds'

getRoomMemberProfile :: Id 'Room -> Id 'User -> Line Profile
getRoomMemberProfile :: Id 'Room -> Id 'User -> Line Profile
getRoomMemberProfile = Proxy GetRoomMemberProfile
-> EmbedLine (Client ClientM (AddHeaders GetRoomMemberProfile))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetRoomMemberProfile
forall k (t :: k). Proxy t
Proxy @GetRoomMemberProfile)

leaveRoom :: Id 'Room -> Line NoContent
leaveRoom :: Id 'Room -> Line NoContent
leaveRoom = Proxy LeaveRoom
-> EmbedLine (Client ClientM (AddHeaders LeaveRoom))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy LeaveRoom
forall k (t :: k). Proxy t
Proxy @LeaveRoom)

getRoomMemberUserIds' :: Id 'Room -> Maybe String -> Line MemberIds
getRoomMemberUserIds' :: Id 'Room -> Maybe String -> Line MemberIds
getRoomMemberUserIds' = Proxy GetRoomMemberUserIds
-> EmbedLine (Client ClientM (AddHeaders GetRoomMemberUserIds))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetRoomMemberUserIds
forall k (t :: k). Proxy t
Proxy @GetRoomMemberUserIds)

getRoomMemberUserIds :: Id 'Room -> Line [Id 'User]
getRoomMemberUserIds :: Id 'Room -> Line [Id 'User]
getRoomMemberUserIds = (Maybe String -> Line MemberIds) -> Line [Id 'User]
unfoldMemberUserIds ((Maybe String -> Line MemberIds) -> Line [Id 'User])
-> (Id 'Room -> Maybe String -> Line MemberIds)
-> Id 'Room
-> Line [Id 'User]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Id 'Room -> Maybe String -> Line MemberIds
getRoomMemberUserIds'

replyMessage' :: ReplyMessageBody -> Line NoContent
replyMessage' :: ReplyMessageBody -> Line NoContent
replyMessage' = Proxy ReplyMessage
-> EmbedLine (Client ClientM (AddHeaders ReplyMessage))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy ReplyMessage
forall k (t :: k). Proxy t
Proxy @ReplyMessage)

replyMessage :: ReplyToken -> [Message] -> Line NoContent
replyMessage :: ReplyToken -> [Message] -> Line NoContent
replyMessage ReplyToken
a [Message]
ms = ReplyMessageBody -> Line NoContent
replyMessage' (ReplyToken -> [Message] -> ReplyMessageBody
ReplyMessageBody ReplyToken
a [Message]
ms)

pushMessage' :: PushMessageBody -> Line NoContent
pushMessage' :: PushMessageBody -> Line NoContent
pushMessage' = Proxy PushMessage
-> EmbedLine (Client ClientM (AddHeaders PushMessage))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy PushMessage
forall k (t :: k). Proxy t
Proxy @PushMessage)

pushMessage :: Id a -> [Message] -> Line NoContent
pushMessage :: Id a -> [Message] -> Line NoContent
pushMessage Id a
a [Message]
ms = PushMessageBody -> Line NoContent
pushMessage' (Id a -> [Message] -> PushMessageBody
forall (a :: ChatType). Id a -> [Message] -> PushMessageBody
PushMessageBody Id a
a [Message]
ms)

multicastMessage' :: MulticastMessageBody -> Line NoContent
multicastMessage' :: MulticastMessageBody -> Line NoContent
multicastMessage' = Proxy MulticastMessage
-> EmbedLine (Client ClientM (AddHeaders MulticastMessage))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy MulticastMessage
forall k (t :: k). Proxy t
Proxy @MulticastMessage)

multicastMessage :: [Id 'User] -> [Message] -> Line NoContent
multicastMessage :: [Id 'User] -> [Message] -> Line NoContent
multicastMessage [Id 'User]
a [Message]
ms = MulticastMessageBody -> Line NoContent
multicastMessage' ([Id 'User] -> [Message] -> MulticastMessageBody
MulticastMessageBody [Id 'User]
a [Message]
ms)

broadcastMessage' :: BroadcastMessageBody -> Line NoContent
broadcastMessage' :: BroadcastMessageBody -> Line NoContent
broadcastMessage' = Proxy BroadcastMessage
-> EmbedLine (Client ClientM (AddHeaders BroadcastMessage))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy BroadcastMessage
forall k (t :: k). Proxy t
Proxy @BroadcastMessage)

broadcastMessage :: [Message] -> Line NoContent
broadcastMessage :: [Message] -> Line NoContent
broadcastMessage = BroadcastMessageBody -> Line NoContent
broadcastMessage' (BroadcastMessageBody -> Line NoContent)
-> ([Message] -> BroadcastMessageBody)
-> [Message]
-> Line NoContent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Message] -> BroadcastMessageBody
BroadcastMessageBody

getContent' :: MessageId -> Line LB.ByteString
getContent' :: Text -> Line ByteString
getContent' = Proxy GetContent
-> EmbedLine (Client ClientM (AddHeaders GetContent))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetContent
forall k (t :: k). Proxy t
Proxy @GetContent)

getContent :: MessageId -> Line LB.ByteString
getContent :: Text -> Line ByteString
getContent = BaseUrl -> Line ByteString -> Line ByteString
forall a. BaseUrl -> Line a -> Line a
withHost BaseUrl
blobEndpoint (Line ByteString -> Line ByteString)
-> (Text -> Line ByteString) -> Text -> Line ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Line ByteString
getContent'

getContentS' :: MessageId -> Line (SourceIO ByteString)
getContentS' :: Text -> Line (SourceIO ByteString)
getContentS' = Proxy GetContentStream
-> EmbedLine (Client ClientM (AddHeaders GetContentStream))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetContentStream
forall k (t :: k). Proxy t
Proxy @GetContentStream)

-- | This is an streaming version of 'getContent' meant to be used with coroutine
-- libraries like @pipes@, @conduits@, @streaming@, etc. You need and instance
-- of 'FromSourceIO', see e.g. @servant-conduit@.
--
-- Example:
--
-- > getContentC :: MessageId -> Line (ConduitT () ByteString IO ())
-- > getContentC = fmap fromSourceIO . getContentS
getContentS :: MessageId -> Line (SourceIO ByteString)
getContentS :: Text -> Line (SourceIO ByteString)
getContentS = BaseUrl -> Line (SourceIO ByteString) -> Line (SourceIO ByteString)
forall a. BaseUrl -> Line a -> Line a
withHost BaseUrl
blobEndpoint (Line (SourceIO ByteString) -> Line (SourceIO ByteString))
-> (Text -> Line (SourceIO ByteString))
-> Text
-> Line (SourceIO ByteString)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Line (SourceIO ByteString)
getContentS'

getPushMessageCount' :: LineDate -> Line MessageCount
getPushMessageCount' :: LineDate -> Line MessageCount
getPushMessageCount' = Proxy GetPushMessageCount
-> EmbedLine (Client ClientM (AddHeaders GetPushMessageCount))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetPushMessageCount
forall k (t :: k). Proxy t
Proxy @GetPushMessageCount)

getPushMessageCount :: Day -> Line (Maybe Int)
getPushMessageCount :: Day -> Line (Maybe Int)
getPushMessageCount = (MessageCount -> Maybe Int)
-> Line MessageCount -> Line (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MessageCount -> Maybe Int
count (Line MessageCount -> Line (Maybe Int))
-> (Day -> Line MessageCount) -> Day -> Line (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LineDate -> Line MessageCount
getPushMessageCount' (LineDate -> Line MessageCount)
-> (Day -> LineDate) -> Day -> Line MessageCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> LineDate
LineDate

getReplyMessageCount' :: LineDate -> Line MessageCount
getReplyMessageCount' :: LineDate -> Line MessageCount
getReplyMessageCount' = Proxy GetReplyMessageCount
-> EmbedLine (Client ClientM (AddHeaders GetReplyMessageCount))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetReplyMessageCount
forall k (t :: k). Proxy t
Proxy @GetReplyMessageCount)

getReplyMessageCount :: Day -> Line (Maybe Int)
getReplyMessageCount :: Day -> Line (Maybe Int)
getReplyMessageCount = (MessageCount -> Maybe Int)
-> Line MessageCount -> Line (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MessageCount -> Maybe Int
count (Line MessageCount -> Line (Maybe Int))
-> (Day -> Line MessageCount) -> Day -> Line (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LineDate -> Line MessageCount
getReplyMessageCount' (LineDate -> Line MessageCount)
-> (Day -> LineDate) -> Day -> Line MessageCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> LineDate
LineDate

getMulticastMessageCount' :: LineDate -> Line MessageCount
getMulticastMessageCount' :: LineDate -> Line MessageCount
getMulticastMessageCount' = Proxy GetMulticastMessageCount
-> EmbedLine (Client ClientM (AddHeaders GetMulticastMessageCount))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetMulticastMessageCount
forall k (t :: k). Proxy t
Proxy @GetMulticastMessageCount)

getMulticastMessageCount :: Day -> Line (Maybe Int)
getMulticastMessageCount :: Day -> Line (Maybe Int)
getMulticastMessageCount = (MessageCount -> Maybe Int)
-> Line MessageCount -> Line (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MessageCount -> Maybe Int
count (Line MessageCount -> Line (Maybe Int))
-> (Day -> Line MessageCount) -> Day -> Line (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LineDate -> Line MessageCount
getMulticastMessageCount' (LineDate -> Line MessageCount)
-> (Day -> LineDate) -> Day -> Line MessageCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> LineDate
LineDate

getBroadcastMessageCount' :: LineDate -> Line MessageCount
getBroadcastMessageCount' :: LineDate -> Line MessageCount
getBroadcastMessageCount' = Proxy GetBroadcastMessageCount
-> EmbedLine (Client ClientM (AddHeaders GetBroadcastMessageCount))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetBroadcastMessageCount
forall k (t :: k). Proxy t
Proxy @GetBroadcastMessageCount)

getBroadcastMessageCount :: Day -> Line (Maybe Int)
getBroadcastMessageCount :: Day -> Line (Maybe Int)
getBroadcastMessageCount = (MessageCount -> Maybe Int)
-> Line MessageCount -> Line (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MessageCount -> Maybe Int
count (Line MessageCount -> Line (Maybe Int))
-> (Day -> Line MessageCount) -> Day -> Line (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LineDate -> Line MessageCount
getBroadcastMessageCount' (LineDate -> Line MessageCount)
-> (Day -> LineDate) -> Day -> Line MessageCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Day -> LineDate
LineDate

getMessageQuota' :: Line MessageQuota
getMessageQuota' :: Line MessageQuota
getMessageQuota' = Proxy GetMessageQuota
-> EmbedLine (Client ClientM (AddHeaders GetMessageQuota))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetMessageQuota
forall k (t :: k). Proxy t
Proxy @GetMessageQuota)

getMessageQuota :: Line Int
getMessageQuota :: Line Int
getMessageQuota = (MessageQuota -> Int) -> Line MessageQuota -> Line Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MessageQuota -> Int
totalUsage Line MessageQuota
getMessageQuota'

issueLinkToken :: Id 'User -> Line LinkToken
issueLinkToken :: Id 'User -> Line LinkToken
issueLinkToken = Proxy IssueLinkToken
-> EmbedLine (Client ClientM (AddHeaders IssueLinkToken))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy IssueLinkToken
forall k (t :: k). Proxy t
Proxy @IssueLinkToken)

issueChannelToken' :: ClientCredentials -> ClientM ShortLivedChannelToken
issueChannelToken' :: ClientCredentials -> ClientM ShortLivedChannelToken
issueChannelToken' = Proxy IssueChannelToken -> Client ClientM IssueChannelToken
forall api.
HasClient ClientM api =>
Proxy api -> Client ClientM api
client (Proxy IssueChannelToken
forall k (t :: k). Proxy t
Proxy @IssueChannelToken)

issueChannelToken :: ChannelId -> ChannelSecret -> ClientM ShortLivedChannelToken
issueChannelToken :: ChannelId -> ChannelSecret -> ClientM ShortLivedChannelToken
issueChannelToken ChannelId
a ChannelSecret
b = ClientCredentials -> ClientM ShortLivedChannelToken
issueChannelToken' (ClientCredentials -> ClientM ShortLivedChannelToken)
-> ClientCredentials -> ClientM ShortLivedChannelToken
forall a b. (a -> b) -> a -> b
$ ChannelId -> ChannelSecret -> ClientCredentials
ClientCredentials ChannelId
a ChannelSecret
b

revokeChannelToken :: ChannelToken -> ClientM NoContent
revokeChannelToken :: ChannelToken -> ClientM NoContent
revokeChannelToken = Proxy RevokeChannelToken -> Client ClientM RevokeChannelToken
forall api.
HasClient ClientM api =>
Proxy api -> Client ClientM api
client (Proxy RevokeChannelToken
forall k (t :: k). Proxy t
Proxy @RevokeChannelToken)

createRichMenu :: RichMenu -> Line RichMenuId
createRichMenu :: RichMenu -> Line RichMenuId
createRichMenu = Proxy CreateRichMenu
-> EmbedLine (Client ClientM (AddHeaders CreateRichMenu))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy CreateRichMenu
forall k (t :: k). Proxy t
Proxy @CreateRichMenu)

getRichMenu' :: RichMenuId -> Line RichMenuResponse
getRichMenu' :: RichMenuId -> Line RichMenuResponse
getRichMenu' = Proxy GetRichMenu
-> EmbedLine (Client ClientM (AddHeaders GetRichMenu))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetRichMenu
forall k (t :: k). Proxy t
Proxy @GetRichMenu)

getRichMenu :: RichMenuId -> Line RichMenu
getRichMenu :: RichMenuId -> Line RichMenu
getRichMenu = (RichMenuResponse -> RichMenu)
-> Line RichMenuResponse -> Line RichMenu
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RichMenuResponse -> RichMenu
richMenu (Line RichMenuResponse -> Line RichMenu)
-> (RichMenuId -> Line RichMenuResponse)
-> RichMenuId
-> Line RichMenu
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RichMenuId -> Line RichMenuResponse
getRichMenu'

uploadRichMenuImageJpg' :: RichMenuId -> ByteString -> Line NoContent
uploadRichMenuImageJpg' :: RichMenuId -> ByteString -> Line NoContent
uploadRichMenuImageJpg' = Proxy UploadRichMenuImageJpg
-> EmbedLine (Client ClientM (AddHeaders UploadRichMenuImageJpg))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy UploadRichMenuImageJpg
forall k (t :: k). Proxy t
Proxy @UploadRichMenuImageJpg)

uploadRichMenuImageJpg :: RichMenuId -> ByteString -> Line NoContent
uploadRichMenuImageJpg :: RichMenuId -> ByteString -> Line NoContent
uploadRichMenuImageJpg RichMenuId
a = BaseUrl -> Line NoContent -> Line NoContent
forall a. BaseUrl -> Line a -> Line a
withHost BaseUrl
blobEndpoint (Line NoContent -> Line NoContent)
-> (ByteString -> Line NoContent) -> ByteString -> Line NoContent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RichMenuId -> ByteString -> Line NoContent
uploadRichMenuImageJpg' RichMenuId
a

deleteRichMenu :: RichMenuId -> Line NoContent
deleteRichMenu :: RichMenuId -> Line NoContent
deleteRichMenu = Proxy DeleteRichMenu
-> EmbedLine (Client ClientM (AddHeaders DeleteRichMenu))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy DeleteRichMenu
forall k (t :: k). Proxy t
Proxy @DeleteRichMenu)

getRichMenuList' :: Line RichMenuResponseList
getRichMenuList' :: Line RichMenuResponseList
getRichMenuList' =  Proxy GetRichMenuList
-> EmbedLine (Client ClientM (AddHeaders GetRichMenuList))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy GetRichMenuList
forall k (t :: k). Proxy t
Proxy @GetRichMenuList)

getRichMenuList :: Line [(RichMenuId, RichMenu)]
getRichMenuList :: Line [(RichMenuId, RichMenu)]
getRichMenuList = RichMenuResponseList -> [RichMenuResponse]
richmenus (RichMenuResponseList -> [RichMenuResponse])
-> Line RichMenuResponseList
-> ReaderT ChannelToken ClientM [RichMenuResponse]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Line RichMenuResponseList
getRichMenuList' ReaderT ChannelToken ClientM [RichMenuResponse]
-> ([RichMenuResponse] -> [(RichMenuId, RichMenu)])
-> Line [(RichMenuId, RichMenu)]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (RichMenuResponse -> (RichMenuId, RichMenu))
-> [RichMenuResponse] -> [(RichMenuId, RichMenu)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RichMenuResponse -> (RichMenuId, RichMenu)
f where
  f :: RichMenuResponse -> (RichMenuId, RichMenu)
f RichMenuResponse{Text
RichMenu
$sel:richMenuId:RichMenuResponse :: RichMenuResponse -> Text
richMenu :: RichMenu
richMenuId :: Text
$sel:richMenu:RichMenuResponse :: RichMenuResponse -> RichMenu
..} = (Text -> RichMenuId
RichMenuId Text
richMenuId, RichMenu
richMenu)

setDefaultRichMenu :: RichMenuId -> Line NoContent
setDefaultRichMenu :: RichMenuId -> Line NoContent
setDefaultRichMenu = Proxy SetDefaultRichMenu
-> EmbedLine (Client ClientM (AddHeaders SetDefaultRichMenu))
forall api.
(HasLine (Client ClientM (AddHeaders api)),
 HasClient ClientM (AddHeaders api)) =>
Proxy api -> EmbedLine (Client ClientM (AddHeaders api))
line (Proxy SetDefaultRichMenu
forall k (t :: k). Proxy t
Proxy @SetDefaultRichMenu)