{-# LANGUAGE DeriveGeneric         #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE RecordWildCards       #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE ScopedTypeVariables   #-}

{- |
Module      :  TwitchAPI.PubSub
Copyright   :  (c) Christina Wuest 2021
License     :  BSD-style

Maintainer  :  tina@wuest.me
Stability   :  experimental
Portability :  non-portable

Messages sent over Twitch's PubSub interface.
-}

module Web.TwitchAPI.PubSub where

import Prelude


import qualified Data.Aeson            as JSON
import qualified Data.Maybe            as Maybe
import qualified Data.Time             as Time
import qualified Data.Time.RFC3339     as Time ( parseTimeRFC3339 )
import qualified Data.Time.Clock.POSIX as Time ( posixSecondsToUTCTime )

import Data.Aeson ( FromJSON(..), (.:), (.:?), withObject, withText, withEmbeddedJSON
                  , ToJSON(..), (.=), object
                  , Object
                  )

import Control.Monad ( mzero )
import GHC.Generics  ( Generic )

import qualified Data.Aeson.Types as JSON.Types

data Topic = BitsV1 { Topic -> Integer
channel :: Integer }
           | BitsV2 { channel :: Integer }
           | BitsBadge { channel :: Integer }
           | ChannelPoints { channel :: Integer }
           | ChannelSubscriptions { channel :: Integer }
           | ChatModeratorActions { channel :: Integer, Topic -> Integer
user :: Integer }
           | Whispers { user :: Integer }
           deriving ( Topic -> Topic -> Bool
(Topic -> Topic -> Bool) -> (Topic -> Topic -> Bool) -> Eq Topic
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Topic -> Topic -> Bool
== :: Topic -> Topic -> Bool
$c/= :: Topic -> Topic -> Bool
/= :: Topic -> Topic -> Bool
Eq, Int -> Topic -> ShowS
[Topic] -> ShowS
Topic -> [Char]
(Int -> Topic -> ShowS)
-> (Topic -> [Char]) -> ([Topic] -> ShowS) -> Show Topic
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Topic -> ShowS
showsPrec :: Int -> Topic -> ShowS
$cshow :: Topic -> [Char]
show :: Topic -> [Char]
$cshowList :: [Topic] -> ShowS
showList :: [Topic] -> ShowS
Show )

toRequest :: Topic -> String
toRequest :: Topic -> [Char]
toRequest BitsV1{Integer
channel :: Topic -> Integer
channel :: Integer
..} = ([Char]
"channel-bits-events-v1." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
channel
toRequest BitsV2{Integer
channel :: Topic -> Integer
channel :: Integer
..} = ([Char]
"channel-bits-events-v2." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
channel
toRequest BitsBadge{Integer
channel :: Topic -> Integer
channel :: Integer
..} = ([Char]
"channel-bits-badge-unlocks." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
channel
toRequest ChannelPoints{Integer
channel :: Topic -> Integer
channel :: Integer
..} = ([Char]
"channel-points-channel-v1." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
channel
toRequest ChannelSubscriptions{Integer
channel :: Topic -> Integer
channel :: Integer
..} = ([Char]
"channel-subscribe-events-v1." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
channel
toRequest ChatModeratorActions{Integer
channel :: Topic -> Integer
user :: Topic -> Integer
channel :: Integer
user :: Integer
..} = [Char]
"chat_moderator_actions." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
user [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
channel
toRequest Whispers{Integer
user :: Topic -> Integer
user :: Integer
..} = ([Char]
"whispers." [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
user

scope :: Topic -> String
scope :: Topic -> [Char]
scope BitsV1{} = [Char]
"bits:read"
scope BitsV2{} = [Char]
"bits:read"
scope BitsBadge{} = [Char]
"bits:read"
scope ChannelPoints{} = [Char]
"channel:read:redemptions"
scope ChannelSubscriptions{} = [Char]
"channel:read:subscriptions"
scope ChatModeratorActions{} = [Char]
"channel:moderate"
scope Whispers{} = [Char]
"whispers:read"

data RequestType = Listen | Unlisten deriving ( RequestType -> RequestType -> Bool
(RequestType -> RequestType -> Bool)
-> (RequestType -> RequestType -> Bool) -> Eq RequestType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestType -> RequestType -> Bool
== :: RequestType -> RequestType -> Bool
$c/= :: RequestType -> RequestType -> Bool
/= :: RequestType -> RequestType -> Bool
Eq )

instance Show RequestType where
    show :: RequestType -> [Char]
show RequestType
Listen   = [Char]
"LISTEN"
    show RequestType
Unlisten = [Char]
"UNLISTEN"

data Request = Request { Request -> RequestType
requestType :: RequestType
                       , Request -> Maybe [Char]
requestNonce :: Maybe String
                       , Request -> [Topic]
topics :: [Topic]
                       , Request -> [Char]
authToken :: String
                       } deriving ( Request -> Request -> Bool
(Request -> Request -> Bool)
-> (Request -> Request -> Bool) -> Eq Request
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Request -> Request -> Bool
== :: Request -> Request -> Bool
$c/= :: Request -> Request -> Bool
/= :: Request -> Request -> Bool
Eq, Int -> Request -> ShowS
[Request] -> ShowS
Request -> [Char]
(Int -> Request -> ShowS)
-> (Request -> [Char]) -> ([Request] -> ShowS) -> Show Request
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Request -> ShowS
showsPrec :: Int -> Request -> ShowS
$cshow :: Request -> [Char]
show :: Request -> [Char]
$cshowList :: [Request] -> ShowS
showList :: [Request] -> ShowS
Show )

instance ToJSON Request where
    toJSON :: Request -> Value
toJSON Request{[Char]
[Topic]
Maybe [Char]
RequestType
requestType :: Request -> RequestType
requestNonce :: Request -> Maybe [Char]
topics :: Request -> [Topic]
authToken :: Request -> [Char]
requestType :: RequestType
requestNonce :: Maybe [Char]
topics :: [Topic]
authToken :: [Char]
..} =
        [Pair] -> Value
object [ Key
"type" Key -> [Char] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= RequestType -> [Char]
forall a. Show a => a -> [Char]
show RequestType
requestType
               , Key
"nonce" Key -> Maybe [Char] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe [Char]
requestNonce
               , Key
"data" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
object [ Key
"topics" Key -> [[Char]] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Topic -> [Char]
toRequest (Topic -> [Char]) -> [Topic] -> [[Char]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Topic]
topics)
                                  , Key
"auth_token" Key -> [Char] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Char]
authToken
                                  ]
               ]

data RequestError = BadMessage | BadAuth | ServerFail | BadTopic | None deriving ( RequestError -> RequestError -> Bool
(RequestError -> RequestError -> Bool)
-> (RequestError -> RequestError -> Bool) -> Eq RequestError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestError -> RequestError -> Bool
== :: RequestError -> RequestError -> Bool
$c/= :: RequestError -> RequestError -> Bool
/= :: RequestError -> RequestError -> Bool
Eq, Int -> RequestError -> ShowS
[RequestError] -> ShowS
RequestError -> [Char]
(Int -> RequestError -> ShowS)
-> (RequestError -> [Char])
-> ([RequestError] -> ShowS)
-> Show RequestError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RequestError -> ShowS
showsPrec :: Int -> RequestError -> ShowS
$cshow :: RequestError -> [Char]
show :: RequestError -> [Char]
$cshowList :: [RequestError] -> ShowS
showList :: [RequestError] -> ShowS
Show )

instance Read RequestError where
    readsPrec :: Int -> ReadS RequestError
readsPrec Int
_ [Char]
"ERR_BADMESSAGE" = [(RequestError
BadMessage, [Char]
"")]
    readsPrec Int
_ [Char]
"ERR_BADAUTH"    = [(RequestError
BadAuth, [Char]
"")]
    readsPrec Int
_ [Char]
"ERR_SERVER"     = [(RequestError
ServerFail, [Char]
"")]
    readsPrec Int
_ [Char]
"ERR_BADTOPIC"   = [(RequestError
BadTopic, [Char]
"")]
    readsPrec Int
_ [Char]
_                = [(RequestError
None, [Char]
"")]

data Response = Response { Response -> Maybe [Char]
responseNonce :: Maybe String
                         , Response -> RequestError
errorReported :: RequestError
                         } deriving ( Int -> Response -> ShowS
[Response] -> ShowS
Response -> [Char]
(Int -> Response -> ShowS)
-> (Response -> [Char]) -> ([Response] -> ShowS) -> Show Response
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Response -> ShowS
showsPrec :: Int -> Response -> ShowS
$cshow :: Response -> [Char]
show :: Response -> [Char]
$cshowList :: [Response] -> ShowS
showList :: [Response] -> ShowS
Show, Response -> Response -> Bool
(Response -> Response -> Bool)
-> (Response -> Response -> Bool) -> Eq Response
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Response -> Response -> Bool
== :: Response -> Response -> Bool
$c/= :: Response -> Response -> Bool
/= :: Response -> Response -> Bool
Eq )

instance FromJSON Response where
    parseJSON :: Value -> Parser Response
parseJSON = [Char] -> (Object -> Parser Response) -> Value -> Parser Response
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"Response" ((Object -> Parser Response) -> Value -> Parser Response)
-> (Object -> Parser Response) -> Value -> Parser Response
forall a b. (a -> b) -> a -> b
$ \Object
o ->
        Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type" Parser [Char] -> ([Char] -> Parser Response) -> Parser Response
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char]
reportedType :: String) ->
        -- This value is required per Twitch or else any response is invalid
        if [Char]
reportedType [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"RESPONSE" then do
            Maybe [Char]
responseNonce <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"nonce"
            [Char]
err <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"error"
            let errorReported :: RequestError
errorReported = [Char] -> RequestError
forall a. Read a => [Char] -> a
read [Char]
err :: RequestError
            Response -> Parser Response
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return Response{Maybe [Char]
RequestError
responseNonce :: Maybe [Char]
errorReported :: RequestError
responseNonce :: Maybe [Char]
errorReported :: RequestError
..}
        else Parser Response
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

-- Used for Channel Points rewards
data RewardImages = RewardImages { RewardImages -> Maybe [Char]
tiny :: Maybe String
                                 , RewardImages -> Maybe [Char]
large :: Maybe String
                                 , RewardImages -> Maybe [Char]
huge :: Maybe String
                                 } deriving ( Int -> RewardImages -> ShowS
[RewardImages] -> ShowS
RewardImages -> [Char]
(Int -> RewardImages -> ShowS)
-> (RewardImages -> [Char])
-> ([RewardImages] -> ShowS)
-> Show RewardImages
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RewardImages -> ShowS
showsPrec :: Int -> RewardImages -> ShowS
$cshow :: RewardImages -> [Char]
show :: RewardImages -> [Char]
$cshowList :: [RewardImages] -> ShowS
showList :: [RewardImages] -> ShowS
Show, RewardImages -> RewardImages -> Bool
(RewardImages -> RewardImages -> Bool)
-> (RewardImages -> RewardImages -> Bool) -> Eq RewardImages
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RewardImages -> RewardImages -> Bool
== :: RewardImages -> RewardImages -> Bool
$c/= :: RewardImages -> RewardImages -> Bool
/= :: RewardImages -> RewardImages -> Bool
Eq, (forall x. RewardImages -> Rep RewardImages x)
-> (forall x. Rep RewardImages x -> RewardImages)
-> Generic RewardImages
forall x. Rep RewardImages x -> RewardImages
forall x. RewardImages -> Rep RewardImages x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RewardImages -> Rep RewardImages x
from :: forall x. RewardImages -> Rep RewardImages x
$cto :: forall x. Rep RewardImages x -> RewardImages
to :: forall x. Rep RewardImages x -> RewardImages
Generic )

instance FromJSON RewardImages where
    parseJSON :: Value -> Parser RewardImages
parseJSON = [Char]
-> (Object -> Parser RewardImages) -> Value -> Parser RewardImages
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"RewardImages" ((Object -> Parser RewardImages) -> Value -> Parser RewardImages)
-> (Object -> Parser RewardImages) -> Value -> Parser RewardImages
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        Maybe [Char]
tiny <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url_1x"
        Maybe [Char]
large <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url_2x"
        Maybe [Char]
huge <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url_4x"
        RewardImages -> Parser RewardImages
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return RewardImages{Maybe [Char]
tiny :: Maybe [Char]
large :: Maybe [Char]
huge :: Maybe [Char]
tiny :: Maybe [Char]
large :: Maybe [Char]
huge :: Maybe [Char]
..}

data UserInfo = UserInfo { UserInfo -> Integer
userId :: Integer
                         , UserInfo -> [Char]
userName :: String
                         , UserInfo -> Maybe [Char]
displayName :: Maybe String
                         } deriving ( UserInfo -> UserInfo -> Bool
(UserInfo -> UserInfo -> Bool)
-> (UserInfo -> UserInfo -> Bool) -> Eq UserInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserInfo -> UserInfo -> Bool
== :: UserInfo -> UserInfo -> Bool
$c/= :: UserInfo -> UserInfo -> Bool
/= :: UserInfo -> UserInfo -> Bool
Eq, Int -> UserInfo -> ShowS
[UserInfo] -> ShowS
UserInfo -> [Char]
(Int -> UserInfo -> ShowS)
-> (UserInfo -> [Char]) -> ([UserInfo] -> ShowS) -> Show UserInfo
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserInfo -> ShowS
showsPrec :: Int -> UserInfo -> ShowS
$cshow :: UserInfo -> [Char]
show :: UserInfo -> [Char]
$cshowList :: [UserInfo] -> ShowS
showList :: [UserInfo] -> ShowS
Show, (forall x. UserInfo -> Rep UserInfo x)
-> (forall x. Rep UserInfo x -> UserInfo) -> Generic UserInfo
forall x. Rep UserInfo x -> UserInfo
forall x. UserInfo -> Rep UserInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UserInfo -> Rep UserInfo x
from :: forall x. UserInfo -> Rep UserInfo x
$cto :: forall x. Rep UserInfo x -> UserInfo
to :: forall x. Rep UserInfo x -> UserInfo
Generic )

instance FromJSON UserInfo where
    parseJSON :: Value -> Parser UserInfo
parseJSON = [Char] -> (Object -> Parser UserInfo) -> Value -> Parser UserInfo
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"UserInfo" ((Object -> Parser UserInfo) -> Value -> Parser UserInfo)
-> (Object -> Parser UserInfo) -> Value -> Parser UserInfo
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        [Char]
userId' <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
        let userId :: Integer
userId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
userId' :: Integer
        [Char]
userName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
        Maybe [Char]
displayName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"display_name"
        UserInfo -> Parser UserInfo
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return UserInfo{Integer
[Char]
Maybe [Char]
userId :: Integer
userName :: [Char]
displayName :: Maybe [Char]
userId :: Integer
userName :: [Char]
displayName :: Maybe [Char]
..}

data RewardStatus = Fulfilled | Unfulfilled deriving ( RewardStatus -> RewardStatus -> Bool
(RewardStatus -> RewardStatus -> Bool)
-> (RewardStatus -> RewardStatus -> Bool) -> Eq RewardStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RewardStatus -> RewardStatus -> Bool
== :: RewardStatus -> RewardStatus -> Bool
$c/= :: RewardStatus -> RewardStatus -> Bool
/= :: RewardStatus -> RewardStatus -> Bool
Eq, Int -> RewardStatus -> ShowS
[RewardStatus] -> ShowS
RewardStatus -> [Char]
(Int -> RewardStatus -> ShowS)
-> (RewardStatus -> [Char])
-> ([RewardStatus] -> ShowS)
-> Show RewardStatus
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RewardStatus -> ShowS
showsPrec :: Int -> RewardStatus -> ShowS
$cshow :: RewardStatus -> [Char]
show :: RewardStatus -> [Char]
$cshowList :: [RewardStatus] -> ShowS
showList :: [RewardStatus] -> ShowS
Show, (forall x. RewardStatus -> Rep RewardStatus x)
-> (forall x. Rep RewardStatus x -> RewardStatus)
-> Generic RewardStatus
forall x. Rep RewardStatus x -> RewardStatus
forall x. RewardStatus -> Rep RewardStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RewardStatus -> Rep RewardStatus x
from :: forall x. RewardStatus -> Rep RewardStatus x
$cto :: forall x. Rep RewardStatus x -> RewardStatus
to :: forall x. Rep RewardStatus x -> RewardStatus
Generic )

instance Read RewardStatus where
    readsPrec :: Int -> ReadS RewardStatus
readsPrec Int
_ [Char]
"FULFILLED" = [(RewardStatus
Fulfilled, [Char]
"")]
    readsPrec Int
_ [Char]
_ = [(RewardStatus
Unfulfilled, [Char]
"")]


data BadgeUnlock = BadgeUnlock { BadgeUnlock -> Integer
newVersion :: Integer
                               , BadgeUnlock -> Integer
previousVersion :: Integer
                               } deriving ( BadgeUnlock -> BadgeUnlock -> Bool
(BadgeUnlock -> BadgeUnlock -> Bool)
-> (BadgeUnlock -> BadgeUnlock -> Bool) -> Eq BadgeUnlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BadgeUnlock -> BadgeUnlock -> Bool
== :: BadgeUnlock -> BadgeUnlock -> Bool
$c/= :: BadgeUnlock -> BadgeUnlock -> Bool
/= :: BadgeUnlock -> BadgeUnlock -> Bool
Eq, Int -> BadgeUnlock -> ShowS
[BadgeUnlock] -> ShowS
BadgeUnlock -> [Char]
(Int -> BadgeUnlock -> ShowS)
-> (BadgeUnlock -> [Char])
-> ([BadgeUnlock] -> ShowS)
-> Show BadgeUnlock
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BadgeUnlock -> ShowS
showsPrec :: Int -> BadgeUnlock -> ShowS
$cshow :: BadgeUnlock -> [Char]
show :: BadgeUnlock -> [Char]
$cshowList :: [BadgeUnlock] -> ShowS
showList :: [BadgeUnlock] -> ShowS
Show, (forall x. BadgeUnlock -> Rep BadgeUnlock x)
-> (forall x. Rep BadgeUnlock x -> BadgeUnlock)
-> Generic BadgeUnlock
forall x. Rep BadgeUnlock x -> BadgeUnlock
forall x. BadgeUnlock -> Rep BadgeUnlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BadgeUnlock -> Rep BadgeUnlock x
from :: forall x. BadgeUnlock -> Rep BadgeUnlock x
$cto :: forall x. Rep BadgeUnlock x -> BadgeUnlock
to :: forall x. Rep BadgeUnlock x -> BadgeUnlock
Generic )

instance FromJSON BadgeUnlock where
    parseJSON :: Value -> Parser BadgeUnlock
parseJSON = [Char]
-> (Object -> Parser BadgeUnlock) -> Value -> Parser BadgeUnlock
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"BadgeUnlock" ((Object -> Parser BadgeUnlock) -> Value -> Parser BadgeUnlock)
-> (Object -> Parser BadgeUnlock) -> Value -> Parser BadgeUnlock
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        Integer
newVersion <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"new_version"
        Integer
previousVersion <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"previous_version"
        BadgeUnlock -> Parser BadgeUnlock
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return BadgeUnlock{Integer
newVersion :: Integer
previousVersion :: Integer
newVersion :: Integer
previousVersion :: Integer
..}

data SubscriptionTier = Prime | Tier1 | Tier2 | Tier3 deriving ( SubscriptionTier -> SubscriptionTier -> Bool
(SubscriptionTier -> SubscriptionTier -> Bool)
-> (SubscriptionTier -> SubscriptionTier -> Bool)
-> Eq SubscriptionTier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubscriptionTier -> SubscriptionTier -> Bool
== :: SubscriptionTier -> SubscriptionTier -> Bool
$c/= :: SubscriptionTier -> SubscriptionTier -> Bool
/= :: SubscriptionTier -> SubscriptionTier -> Bool
Eq, Int -> SubscriptionTier -> ShowS
[SubscriptionTier] -> ShowS
SubscriptionTier -> [Char]
(Int -> SubscriptionTier -> ShowS)
-> (SubscriptionTier -> [Char])
-> ([SubscriptionTier] -> ShowS)
-> Show SubscriptionTier
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubscriptionTier -> ShowS
showsPrec :: Int -> SubscriptionTier -> ShowS
$cshow :: SubscriptionTier -> [Char]
show :: SubscriptionTier -> [Char]
$cshowList :: [SubscriptionTier] -> ShowS
showList :: [SubscriptionTier] -> ShowS
Show, (forall x. SubscriptionTier -> Rep SubscriptionTier x)
-> (forall x. Rep SubscriptionTier x -> SubscriptionTier)
-> Generic SubscriptionTier
forall x. Rep SubscriptionTier x -> SubscriptionTier
forall x. SubscriptionTier -> Rep SubscriptionTier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubscriptionTier -> Rep SubscriptionTier x
from :: forall x. SubscriptionTier -> Rep SubscriptionTier x
$cto :: forall x. Rep SubscriptionTier x -> SubscriptionTier
to :: forall x. Rep SubscriptionTier x -> SubscriptionTier
Generic )

instance FromJSON SubscriptionTier where
    parseJSON :: Value -> Parser SubscriptionTier
parseJSON = [Char]
-> (Text -> Parser SubscriptionTier)
-> Value
-> Parser SubscriptionTier
forall a. [Char] -> (Text -> Parser a) -> Value -> Parser a
withText [Char]
"SubscriptionTier" ((Text -> Parser SubscriptionTier)
 -> Value -> Parser SubscriptionTier)
-> (Text -> Parser SubscriptionTier)
-> Value
-> Parser SubscriptionTier
forall a b. (a -> b) -> a -> b
$ \case
        Text
"1000" -> SubscriptionTier -> Parser SubscriptionTier
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return SubscriptionTier
Tier1
        Text
"2000" -> SubscriptionTier -> Parser SubscriptionTier
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return SubscriptionTier
Tier2
        Text
"3000" -> SubscriptionTier -> Parser SubscriptionTier
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return SubscriptionTier
Tier3
        Text
"Prime" -> SubscriptionTier -> Parser SubscriptionTier
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return SubscriptionTier
Prime
        Text
_ -> Parser SubscriptionTier
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

data EmoteSpec = EmoteSpec { EmoteSpec -> Integer
emoteStart :: Integer
                           , EmoteSpec -> Integer
emoteLength :: Integer
                           , EmoteSpec -> Integer
emoteId :: Integer
                           } deriving ( EmoteSpec -> EmoteSpec -> Bool
(EmoteSpec -> EmoteSpec -> Bool)
-> (EmoteSpec -> EmoteSpec -> Bool) -> Eq EmoteSpec
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EmoteSpec -> EmoteSpec -> Bool
== :: EmoteSpec -> EmoteSpec -> Bool
$c/= :: EmoteSpec -> EmoteSpec -> Bool
/= :: EmoteSpec -> EmoteSpec -> Bool
Eq, Int -> EmoteSpec -> ShowS
[EmoteSpec] -> ShowS
EmoteSpec -> [Char]
(Int -> EmoteSpec -> ShowS)
-> (EmoteSpec -> [Char])
-> ([EmoteSpec] -> ShowS)
-> Show EmoteSpec
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EmoteSpec -> ShowS
showsPrec :: Int -> EmoteSpec -> ShowS
$cshow :: EmoteSpec -> [Char]
show :: EmoteSpec -> [Char]
$cshowList :: [EmoteSpec] -> ShowS
showList :: [EmoteSpec] -> ShowS
Show, (forall x. EmoteSpec -> Rep EmoteSpec x)
-> (forall x. Rep EmoteSpec x -> EmoteSpec) -> Generic EmoteSpec
forall x. Rep EmoteSpec x -> EmoteSpec
forall x. EmoteSpec -> Rep EmoteSpec x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EmoteSpec -> Rep EmoteSpec x
from :: forall x. EmoteSpec -> Rep EmoteSpec x
$cto :: forall x. Rep EmoteSpec x -> EmoteSpec
to :: forall x. Rep EmoteSpec x -> EmoteSpec
Generic )

instance FromJSON EmoteSpec where
    parseJSON :: Value -> Parser EmoteSpec
parseJSON = [Char] -> (Object -> Parser EmoteSpec) -> Value -> Parser EmoteSpec
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"EmoteSpec" ((Object -> Parser EmoteSpec) -> Value -> Parser EmoteSpec)
-> (Object -> Parser EmoteSpec) -> Value -> Parser EmoteSpec
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        Integer
emoteStart <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"start"
        Integer
emoteEnd :: Integer <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"end"
        Maybe [Char]
emoteId' :: Maybe String <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"id"
        let emoteLength :: Integer
emoteLength = Integer
1 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
emoteEnd Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
emoteStart
        case Maybe [Char]
emoteId' of
            Just [Char]
emoteId'' ->
                let emoteId :: Integer
emoteId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
emoteId'' :: Integer
                in EmoteSpec -> Parser EmoteSpec
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return EmoteSpec{Integer
emoteStart :: Integer
emoteLength :: Integer
emoteId :: Integer
emoteStart :: Integer
emoteLength :: Integer
emoteId :: Integer
..}
            Maybe [Char]
Nothing -> do
                [Char]
altEmoteId :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"emote_id"
                let emoteId :: Integer
emoteId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
altEmoteId :: Integer
                EmoteSpec -> Parser EmoteSpec
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return EmoteSpec{Integer
emoteStart :: Integer
emoteLength :: Integer
emoteId :: Integer
emoteStart :: Integer
emoteLength :: Integer
emoteId :: Integer
..}

data SubscriptionMessage = SubscriptionMessage { SubscriptionMessage -> [Char]
subscriptionMessage :: String
                                               , SubscriptionMessage -> [EmoteSpec]
subscriptionEmotes :: [EmoteSpec]
                                               } deriving ( SubscriptionMessage -> SubscriptionMessage -> Bool
(SubscriptionMessage -> SubscriptionMessage -> Bool)
-> (SubscriptionMessage -> SubscriptionMessage -> Bool)
-> Eq SubscriptionMessage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubscriptionMessage -> SubscriptionMessage -> Bool
== :: SubscriptionMessage -> SubscriptionMessage -> Bool
$c/= :: SubscriptionMessage -> SubscriptionMessage -> Bool
/= :: SubscriptionMessage -> SubscriptionMessage -> Bool
Eq, Int -> SubscriptionMessage -> ShowS
[SubscriptionMessage] -> ShowS
SubscriptionMessage -> [Char]
(Int -> SubscriptionMessage -> ShowS)
-> (SubscriptionMessage -> [Char])
-> ([SubscriptionMessage] -> ShowS)
-> Show SubscriptionMessage
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubscriptionMessage -> ShowS
showsPrec :: Int -> SubscriptionMessage -> ShowS
$cshow :: SubscriptionMessage -> [Char]
show :: SubscriptionMessage -> [Char]
$cshowList :: [SubscriptionMessage] -> ShowS
showList :: [SubscriptionMessage] -> ShowS
Show, (forall x. SubscriptionMessage -> Rep SubscriptionMessage x)
-> (forall x. Rep SubscriptionMessage x -> SubscriptionMessage)
-> Generic SubscriptionMessage
forall x. Rep SubscriptionMessage x -> SubscriptionMessage
forall x. SubscriptionMessage -> Rep SubscriptionMessage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubscriptionMessage -> Rep SubscriptionMessage x
from :: forall x. SubscriptionMessage -> Rep SubscriptionMessage x
$cto :: forall x. Rep SubscriptionMessage x -> SubscriptionMessage
to :: forall x. Rep SubscriptionMessage x -> SubscriptionMessage
Generic )

instance FromJSON SubscriptionMessage where
    parseJSON :: Value -> Parser SubscriptionMessage
parseJSON = [Char]
-> (Object -> Parser SubscriptionMessage)
-> Value
-> Parser SubscriptionMessage
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"SubscriptionMessage" ((Object -> Parser SubscriptionMessage)
 -> Value -> Parser SubscriptionMessage)
-> (Object -> Parser SubscriptionMessage)
-> Value
-> Parser SubscriptionMessage
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        [Char]
subscriptionMessage <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message"
        Maybe [EmoteSpec]
emotes' <- Object
o Object -> Key -> Parser (Maybe [EmoteSpec])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"emotes"
        let subscriptionEmotes :: [EmoteSpec]
subscriptionEmotes = [EmoteSpec] -> Maybe [EmoteSpec] -> [EmoteSpec]
forall a. a -> Maybe a -> a
Maybe.fromMaybe [] Maybe [EmoteSpec]
emotes'
        SubscriptionMessage -> Parser SubscriptionMessage
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return SubscriptionMessage{[Char]
[EmoteSpec]
subscriptionMessage :: [Char]
subscriptionEmotes :: [EmoteSpec]
subscriptionMessage :: [Char]
subscriptionEmotes :: [EmoteSpec]
..}

data Message = BitsV2Message { Message -> Maybe BadgeUnlock
badge :: Maybe BadgeUnlock
                             , Message -> Integer
bits :: Integer
                             , Message -> Integer
channelId :: Integer
                             , Message -> Maybe [Char]
chatMessage :: Maybe String
                             , Message -> [Char]
context :: String
                             , Message -> [Char]
messageId :: String
                             , Message -> [Char]
messageType :: String
                             , Message -> Maybe UTCTime
time :: Maybe Time.UTCTime
                             , Message -> Integer
userTotal :: Integer
                             , Message -> Maybe Integer
messageUser :: Maybe Integer
                             , Message -> Maybe [Char]
messageUserName :: Maybe String
                             , Message -> [Char]
version :: String
                             }
             | BitsV2AnonymousMessage { bits :: Integer
                                      , channelId :: Integer
                                      , chatMessage :: Maybe String
                                      , context :: String
                                      , messageId :: String
                                      , messageType :: String
                                      , time :: Maybe Time.UTCTime
                                      , version :: String
                                      }
             | BitsV1Message { badge :: Maybe BadgeUnlock
                             , bits :: Integer
                             , channelId :: Integer
                             , Message -> [Char]
channelName :: String
                             , chatMessage :: Maybe String
                             , context :: String
                             , messageId :: String
                             , messageType :: String
                             , time :: Maybe Time.UTCTime
                             , userTotal :: Integer
                             , messageUser :: Maybe Integer
                             , messageUserName :: Maybe String
                             , version :: String
                             }
             | BitsBadgeMessage { messageUser :: Maybe Integer
                                , messageUserName :: Maybe String
                                , channelId :: Integer
                                , channelName :: String
                                , Message -> Integer
bitsTier :: Integer
                                , chatMessage :: Maybe String
                                , time :: Maybe Time.UTCTime
                                }
             | ChannelPointsMessage { Message -> Maybe UTCTime
serverTime :: Maybe Time.UTCTime
                                    , Message -> Maybe UTCTime
redeemedTime :: Maybe Time.UTCTime
                                    , Message -> UserInfo
userInfo :: UserInfo
                                    , Message -> [Char]
rewardId :: String
                                    , channelId :: Integer
                                    , Message -> [Char]
title :: String
                                    , Message -> Maybe [Char]
prompt :: Maybe String
                                    , Message -> Integer
cost :: Integer
                                    , Message -> Maybe [Char]
userInput :: Maybe String
                                    , Message -> Bool
subOnly :: Bool
                                    , Message -> Maybe RewardImages
image :: Maybe RewardImages
                                    , Message -> RewardImages
defaultImage :: RewardImages
                                    , Message -> [Char]
backgroundColor :: String
                                    , Message -> Bool
enabled :: Bool
                                    , Message -> Bool
paused :: Bool
                                    , Message -> Bool
inStock :: Bool
                                    , Message -> Maybe Integer
maxPerStream :: Maybe Integer
                                    , Message -> Bool
autoFulfilled :: Bool
                                    , Message -> RewardStatus
status :: RewardStatus
                                    }
             | ChannelSubscriptionMessage { userInfo :: UserInfo
                                          , channelName :: String
                                          , channelId :: Integer
                                          , time :: Maybe Time.UTCTime
                                          , Message -> SubscriptionTier
subTier :: SubscriptionTier
                                          , Message -> [Char]
subPlanName :: String
                                          , Message -> SubscriptionMessage
subMessage :: SubscriptionMessage
                                          }
             | ChannelResubscriptionMessage { userInfo :: UserInfo
                                            , channelName :: String
                                            , channelId :: Integer
                                            , time :: Maybe Time.UTCTime
                                            , subTier :: SubscriptionTier
                                            , subPlanName :: String
                                            , Message -> Integer
totalMonths :: Integer
                                            , Message -> Maybe Integer
streakMonths :: Maybe Integer
                                            , subMessage :: SubscriptionMessage
                                            }
             | ChannelExtendSubscriptionMessage { userInfo :: UserInfo
                                                , channelName :: String
                                                , channelId :: Integer
                                                , time :: Maybe Time.UTCTime
                                                , subTier :: SubscriptionTier
                                                , subPlanName :: String
                                                , totalMonths :: Integer
                                                , streakMonths :: Maybe Integer
                                                , Message -> Integer
endMonth :: Integer
                                                , subMessage :: SubscriptionMessage
                                                }
             | ChannelSubscriptionGiftMessage { userInfo :: UserInfo
                                              , channelName :: String
                                              , channelId :: Integer
                                              , time :: Maybe Time.UTCTime
                                              , subTier :: SubscriptionTier
                                              , subPlanName :: String
                                              , Message -> UserInfo
recipient :: UserInfo
                                              }
             | ChannelMultiMonthSubscriptionGiftMessage { userInfo :: UserInfo
                                                        , channelName :: String
                                                        , channelId :: Integer
                                                        , time :: Maybe Time.UTCTime
                                                        , subTier :: SubscriptionTier
                                                        , subPlanName :: String
                                                        , recipient :: UserInfo
                                                        , Message -> Integer
months :: Integer
                                                        }
             | ChannelAnonymousSubscriptionGiftMessage { channelName :: String
                                                       , channelId :: Integer
                                                       , time :: Maybe Time.UTCTime
                                                       , subTier :: SubscriptionTier
                                                       , subPlanName :: String
                                                       , recipient :: UserInfo
                                                       }
             | ChannelAnonymousMultiMonthSubscriptionGiftMessage { channelName :: String
                                                                 , channelId :: Integer
                                                                 , time :: Maybe Time.UTCTime
                                                                 , subTier :: SubscriptionTier
                                                                 , subPlanName :: String
                                                                 , recipient :: UserInfo
                                                                 , months :: Integer
                                                                 }
             | WhisperMessage { messageId :: String
                              , Message -> [Char]
threadId :: String
                              , time :: Maybe Time.UTCTime
                              , Message -> [Char]
messageBody :: String
                              , Message -> [EmoteSpec]
messageEmotes :: [EmoteSpec]
                              , userInfo :: UserInfo
                              , Message -> [Char]
userColor :: String
                              , recipient :: UserInfo
                              }
             | SuccessMessage { Message -> Maybe [Char]
nonce :: Maybe String }
             | ErrorMessage { nonce :: Maybe String
                            , Message -> [Char]
errorString :: String
                            } deriving ( Message -> Message -> Bool
(Message -> Message -> Bool)
-> (Message -> Message -> Bool) -> Eq Message
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Message -> Message -> Bool
== :: Message -> Message -> Bool
$c/= :: Message -> Message -> Bool
/= :: Message -> Message -> Bool
Eq, Int -> Message -> ShowS
[Message] -> ShowS
Message -> [Char]
(Int -> Message -> ShowS)
-> (Message -> [Char]) -> ([Message] -> ShowS) -> Show Message
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Message -> ShowS
showsPrec :: Int -> Message -> ShowS
$cshow :: Message -> [Char]
show :: Message -> [Char]
$cshowList :: [Message] -> ShowS
showList :: [Message] -> ShowS
Show, (forall x. Message -> Rep Message x)
-> (forall x. Rep Message x -> Message) -> Generic Message
forall x. Rep Message x -> Message
forall x. Message -> Rep Message x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Message -> Rep Message x
from :: forall x. Message -> Rep Message x
$cto :: forall x. Rep Message x -> Message
to :: forall x. Rep Message x -> Message
Generic )

instance JSON.ToJSON EmoteSpec
instance JSON.ToJSON SubscriptionMessage
instance JSON.ToJSON SubscriptionTier
instance JSON.ToJSON RewardStatus
instance JSON.ToJSON RewardImages
instance JSON.ToJSON UserInfo
instance JSON.ToJSON BadgeUnlock
instance JSON.ToJSON Message

type MessageParser = Object -> JSON.Types.Parser Message

parseChannelSubscribeEvent :: MessageParser
parseChannelSubscribeEvent :: MessageParser
parseChannelSubscribeEvent Object
o = do
    [Char]
uid :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
    [Char]
messageUserName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
    Maybe [Char]
displayName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"display_name"
    let messageUser :: Integer
messageUser = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
uid :: Integer
        userInfo :: UserInfo
userInfo = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
messageUser [Char]
messageUserName Maybe [Char]
displayName

    [Char]
channelName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_name"
    [Char]
channel <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
t :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    SubscriptionTier
subTier <- Object
o Object -> Key -> Parser SubscriptionTier
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan"
    [Char]
subPlanName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan_name"
    SubscriptionMessage
subMessage <- Object
o Object -> Key -> Parser SubscriptionMessage
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_message"

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelSubscriptionMessage{Integer
[Char]
Maybe UTCTime
SubscriptionMessage
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
userInfo :: UserInfo
subTier :: SubscriptionTier
subPlanName :: [Char]
subMessage :: SubscriptionMessage
userInfo :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
subMessage :: SubscriptionMessage
..}

parseChannelResubscribeEvent :: MessageParser
parseChannelResubscribeEvent :: MessageParser
parseChannelResubscribeEvent Object
o = do
    [Char]
uid :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
    [Char]
messageUserName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
    Maybe [Char]
displayName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"display_name"
    let messageUser :: Integer
messageUser = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
uid :: Integer
        userInfo :: UserInfo
userInfo = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
messageUser [Char]
messageUserName Maybe [Char]
displayName

    [Char]
channelName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_name"
    [Char]
channel <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
t :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    SubscriptionTier
subTier <- Object
o Object -> Key -> Parser SubscriptionTier
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan"
    [Char]
subPlanName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan_name"
    Integer
totalMonths <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"cumulative_months"
    Maybe Integer
streakMonths <- Object
o Object -> Key -> Parser (Maybe Integer)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"streak_months"
    SubscriptionMessage
subMessage <- Object
o Object -> Key -> Parser SubscriptionMessage
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_message"

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelResubscriptionMessage{Integer
[Char]
Maybe Integer
Maybe UTCTime
SubscriptionMessage
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
userInfo :: UserInfo
subTier :: SubscriptionTier
subPlanName :: [Char]
subMessage :: SubscriptionMessage
totalMonths :: Integer
streakMonths :: Maybe Integer
userInfo :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
totalMonths :: Integer
streakMonths :: Maybe Integer
subMessage :: SubscriptionMessage
..}

parseChannelExtendSubEvent :: MessageParser
parseChannelExtendSubEvent :: MessageParser
parseChannelExtendSubEvent Object
o = do
    [Char]
uid :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
    [Char]
messageUserName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
    Maybe [Char]
displayName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"display_name"
    let messageUser :: Integer
messageUser = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
uid :: Integer
        userInfo :: UserInfo
userInfo = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
messageUser [Char]
messageUserName Maybe [Char]
displayName

    [Char]
channelName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_name"
    [Char]
channel <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
t :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    SubscriptionTier
subTier <- Object
o Object -> Key -> Parser SubscriptionTier
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan"
    [Char]
subPlanName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan_name"
    Integer
totalMonths <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"cumulative_months"
    Integer
endMonth <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"benefit_end_month"
    Maybe Integer
streakMonths <- Object
o Object -> Key -> Parser (Maybe Integer)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"streak_months"
    SubscriptionMessage
subMessage <- Object
o Object -> Key -> Parser SubscriptionMessage
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_message"

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelExtendSubscriptionMessage{Integer
[Char]
Maybe Integer
Maybe UTCTime
SubscriptionMessage
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
userInfo :: UserInfo
subTier :: SubscriptionTier
subPlanName :: [Char]
subMessage :: SubscriptionMessage
totalMonths :: Integer
streakMonths :: Maybe Integer
endMonth :: Integer
userInfo :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
totalMonths :: Integer
endMonth :: Integer
streakMonths :: Maybe Integer
subMessage :: SubscriptionMessage
..}

parseChannelSubGiftEvent :: MessageParser
parseChannelSubGiftEvent :: MessageParser
parseChannelSubGiftEvent Object
o = do
    [Char]
uid :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
    [Char]
messageUserName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
    Maybe [Char]
displayName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"display_name"
    let messageUser :: Integer
messageUser = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
uid :: Integer
        userInfo :: UserInfo
userInfo = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
messageUser [Char]
messageUserName Maybe [Char]
displayName

    [Char]
rid :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recipient_id"
    [Char]
rUserName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recipient_user_name"
    Maybe [Char]
rDisplayName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recipient_display_name"
    let rUserId :: Integer
rUserId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
rid :: Integer
        recipient :: UserInfo
recipient = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
rUserId [Char]
rUserName Maybe [Char]
rDisplayName

    [Char]
channelName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_name"
    [Char]
channel <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
t :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    SubscriptionTier
subTier <- Object
o Object -> Key -> Parser SubscriptionTier
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan"
    [Char]
subPlanName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan_name"

    Maybe Integer
duration :: Maybe Integer <- Object
o Object -> Key -> Parser (Maybe Integer)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"multi_month_duration"
    case Maybe Integer
duration of
        Maybe Integer
Nothing -> Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelSubscriptionGiftMessage{Integer
[Char]
Maybe UTCTime
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
userInfo :: UserInfo
subTier :: SubscriptionTier
subPlanName :: [Char]
recipient :: UserInfo
userInfo :: UserInfo
recipient :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
..}
        Just Integer
1 -> Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelSubscriptionGiftMessage{Integer
[Char]
Maybe UTCTime
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
userInfo :: UserInfo
subTier :: SubscriptionTier
subPlanName :: [Char]
recipient :: UserInfo
userInfo :: UserInfo
recipient :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
..}
        Just Integer
months -> Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelMultiMonthSubscriptionGiftMessage{Integer
[Char]
Maybe UTCTime
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
userInfo :: UserInfo
subTier :: SubscriptionTier
subPlanName :: [Char]
recipient :: UserInfo
months :: Integer
userInfo :: UserInfo
recipient :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
months :: Integer
..}

parseChannelAnonSubGiftEvent :: MessageParser
parseChannelAnonSubGiftEvent :: MessageParser
parseChannelAnonSubGiftEvent Object
o = do
    [Char]
rid :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recipient_id"
    [Char]
rUserName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recipient_user_name"
    Maybe [Char]
rDisplayName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recipient_display_name"
    let rUserId :: Integer
rUserId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
rid :: Integer
        recipient :: UserInfo
recipient = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
rUserId [Char]
rUserName Maybe [Char]
rDisplayName

    [Char]
channelName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_name"
    [Char]
channel <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
t :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    SubscriptionTier
subTier <- Object
o Object -> Key -> Parser SubscriptionTier
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan"
    [Char]
subPlanName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sub_plan_name"

    Maybe Integer
duration :: Maybe Integer <- Object
o Object -> Key -> Parser (Maybe Integer)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"multi_month_duration"
    case Maybe Integer
duration of
        Maybe Integer
Nothing -> Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelAnonymousSubscriptionGiftMessage{Integer
[Char]
Maybe UTCTime
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
subTier :: SubscriptionTier
subPlanName :: [Char]
recipient :: UserInfo
recipient :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
..}
        Just Integer
1 -> Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelAnonymousSubscriptionGiftMessage{Integer
[Char]
Maybe UTCTime
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
subTier :: SubscriptionTier
subPlanName :: [Char]
recipient :: UserInfo
recipient :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
..}
        Just Integer
months -> Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelAnonymousMultiMonthSubscriptionGiftMessage{Integer
[Char]
Maybe UTCTime
SubscriptionTier
UserInfo
channelId :: Integer
time :: Maybe UTCTime
channelName :: [Char]
subTier :: SubscriptionTier
subPlanName :: [Char]
recipient :: UserInfo
months :: Integer
recipient :: UserInfo
channelName :: [Char]
channelId :: Integer
time :: Maybe UTCTime
subTier :: SubscriptionTier
subPlanName :: [Char]
months :: Integer
..}

parseChannelSubscribeMessage :: MessageParser
parseChannelSubscribeMessage :: MessageParser
parseChannelSubscribeMessage Object
o = do
    [Char]
context :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"context"
    case [Char]
context of
      [Char]
"sub" -> MessageParser
parseChannelSubscribeEvent Object
o
      [Char]
"resub" -> MessageParser
parseChannelResubscribeEvent Object
o
      [Char]
"extendsub" -> MessageParser
parseChannelExtendSubEvent Object
o
      [Char]
"subgift" -> MessageParser
parseChannelSubGiftEvent Object
o
      [Char]
"resubgift" -> MessageParser
parseChannelSubGiftEvent Object
o
      [Char]
"anonsubgift" -> MessageParser
parseChannelAnonSubGiftEvent Object
o
      [Char]
"anonresubgift" -> MessageParser
parseChannelAnonSubGiftEvent Object
o
      [Char]
_ -> Parser Message
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

parseBitsV2Message :: MessageParser
parseBitsV2Message :: MessageParser
parseBitsV2Message Object
o = do
    Object
dat <- Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data"
    Maybe Bool
anonymous :: Maybe Bool <- Object
o Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"is_anonymous"
    case Maybe Bool
anonymous of
      Maybe Bool
Nothing      -> Object -> MessageParser
parseBitsV2 Object
o Object
dat
      (Just Bool
False) -> Object -> MessageParser
parseBitsV2 Object
o Object
dat
      (Just Bool
True)  -> Object -> MessageParser
parseBitsV2Anonymous Object
o Object
dat


parseBitsV2 :: Object -> MessageParser
parseBitsV2 :: Object -> MessageParser
parseBitsV2 Object
o Object
dat = do
    Maybe BadgeUnlock
badge <- Object
dat Object -> Key -> Parser (Maybe BadgeUnlock)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"badge_entitlement"
    Integer
bits <- Object
dat Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"bits_used"
    Maybe [Char]
chatMessage <- Object
dat Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"chat_message"
    [Char]
context <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"context"
    [Char]
messageId <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message_id"
    [Char]
messageType <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message_type" -- Always bits_event?  No other examples given in API docs
    Integer
userTotal <- Object
dat Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_bits_used"
    Maybe [Char]
messageUserName <- Object
dat Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
    [Char]
version <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"

    [Char]
channel :: String <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    Maybe [Char]
uid :: Maybe String <- Object
dat Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
    let messageUser :: Maybe Integer
messageUser = ([Char] -> Integer) -> Maybe [Char] -> Maybe Integer
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char] -> Integer
forall a. Read a => [Char] -> a
read :: String -> Integer) Maybe [Char]
uid

    [Char]
t :: String <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return BitsV2Message{Integer
[Char]
Maybe Integer
Maybe [Char]
Maybe UTCTime
Maybe BadgeUnlock
badge :: Maybe BadgeUnlock
bits :: Integer
channelId :: Integer
chatMessage :: Maybe [Char]
context :: [Char]
messageId :: [Char]
messageType :: [Char]
time :: Maybe UTCTime
userTotal :: Integer
messageUser :: Maybe Integer
messageUserName :: Maybe [Char]
version :: [Char]
badge :: Maybe BadgeUnlock
bits :: Integer
chatMessage :: Maybe [Char]
context :: [Char]
messageId :: [Char]
messageType :: [Char]
userTotal :: Integer
messageUserName :: Maybe [Char]
version :: [Char]
channelId :: Integer
messageUser :: Maybe Integer
time :: Maybe UTCTime
..}

parseBitsV2Anonymous :: Object -> MessageParser
parseBitsV2Anonymous :: Object -> MessageParser
parseBitsV2Anonymous Object
o Object
dat = do
    Integer
bits <- Object
dat Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"bits_used"
    Maybe [Char]
chatMessage <- Object
dat Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"chat_message"
    [Char]
context <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"context"
    [Char]
messageId <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message_id"
    [Char]
messageType <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message_type" -- Always bits_event?  No other examples given in API docs
    [Char]
version <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"

    [Char]
channel :: String <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
t :: String <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return BitsV2AnonymousMessage{Integer
[Char]
Maybe [Char]
Maybe UTCTime
bits :: Integer
channelId :: Integer
chatMessage :: Maybe [Char]
context :: [Char]
messageId :: [Char]
messageType :: [Char]
time :: Maybe UTCTime
version :: [Char]
bits :: Integer
chatMessage :: Maybe [Char]
context :: [Char]
messageId :: [Char]
messageType :: [Char]
version :: [Char]
channelId :: Integer
time :: Maybe UTCTime
..}

parseBitsV1Message :: MessageParser
parseBitsV1Message :: MessageParser
parseBitsV1Message Object
o = do
    Object
dat <- Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data"
    Maybe BadgeUnlock
badge <- Object
dat Object -> Key -> Parser (Maybe BadgeUnlock)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"badge_entitlement"
    Integer
bits <- Object
dat Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"bits_used"
    [Char]
channelName <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_name"
    Maybe [Char]
chatMessage <- Object
dat Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"chat_message"
    [Char]
context <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"context"
    [Char]
messageId <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message_id"
    [Char]
messageType <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message_type" -- Always bits_event?  No other examples given in API docs
    Integer
userTotal <- Object
dat Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_bits_used"
    Maybe [Char]
messageUserName <- Object
dat Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
    [Char]
version <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"version"

    Maybe [Char]
uid :: Maybe String <- Object
dat Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
    let messageUser :: Maybe Integer
messageUser = ([Char] -> Integer) -> Maybe [Char] -> Maybe Integer
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char] -> Integer
forall a. Read a => [Char] -> a
read :: String -> Integer) Maybe [Char]
uid

    [Char]
channel :: String <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
t :: String <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return BitsV1Message{Integer
[Char]
Maybe Integer
Maybe [Char]
Maybe UTCTime
Maybe BadgeUnlock
badge :: Maybe BadgeUnlock
bits :: Integer
channelId :: Integer
chatMessage :: Maybe [Char]
context :: [Char]
messageId :: [Char]
messageType :: [Char]
time :: Maybe UTCTime
userTotal :: Integer
messageUser :: Maybe Integer
messageUserName :: Maybe [Char]
version :: [Char]
channelName :: [Char]
badge :: Maybe BadgeUnlock
bits :: Integer
channelName :: [Char]
chatMessage :: Maybe [Char]
context :: [Char]
messageId :: [Char]
messageType :: [Char]
userTotal :: Integer
messageUserName :: Maybe [Char]
version :: [Char]
messageUser :: Maybe Integer
channelId :: Integer
time :: Maybe UTCTime
..}

parseBitsBadgeMessage :: MessageParser
parseBitsBadgeMessage :: MessageParser
parseBitsBadgeMessage Object
o = do
    Maybe Integer
messageUser <- Object
o Object -> Key -> Parser (Maybe Integer)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
    Maybe [Char]
messageUserName <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
    [Char]
channelName <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_name"
    Integer
bitsTier <- Object
o Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"badge_tier"
    Maybe [Char]
chatMessage <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"chat_message"

    [Char]
channel :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    [Char]
t :: String <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"time"
    let time :: Maybe UTCTime
time = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
t
        channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer
    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return BitsBadgeMessage{Integer
[Char]
Maybe Integer
Maybe [Char]
Maybe UTCTime
channelId :: Integer
chatMessage :: Maybe [Char]
time :: Maybe UTCTime
messageUser :: Maybe Integer
messageUserName :: Maybe [Char]
channelName :: [Char]
bitsTier :: Integer
messageUser :: Maybe Integer
messageUserName :: Maybe [Char]
channelName :: [Char]
bitsTier :: Integer
chatMessage :: Maybe [Char]
time :: Maybe UTCTime
channelId :: Integer
..}

parseRewardMessage :: MessageParser
parseRewardMessage :: MessageParser
parseRewardMessage Object
o = do
    Object
dat <- Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data"
    Object
redemption <- Object
dat Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"redemption"
    Object
reward <- Object
redemption Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"reward"
    UserInfo
userInfo <- Object
redemption Object -> Key -> Parser UserInfo
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
    [Char]
rewardId <- Object
reward Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
    [Char]
title <- Object
reward Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"title"
    Maybe [Char]
prompt <- Object
reward Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prompt"
    Integer
cost <- Object
reward Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"cost"
    Bool
subOnly <- Object
reward Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_sub_only"
    Maybe RewardImages
image <- Object
reward Object -> Key -> Parser (Maybe RewardImages)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"image"
    RewardImages
defaultImage <- Object
reward Object -> Key -> Parser RewardImages
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"default_image"
    [Char]
backgroundColor <- Object
reward Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"background_color"
    Bool
enabled <- Object
reward Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_enabled"
    Bool
paused <- Object
reward Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_paused"
    Bool
inStock <- Object
reward Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_in_stock"
    Bool
autoFulfilled <- Object
reward Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"should_redemptions_skip_request_queue"

    [Char]
channel :: String <- Object
redemption Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"channel_id"
    let channelId :: Integer
channelId = [Char] -> Integer
forall a. Read a => [Char] -> a
read [Char]
channel :: Integer

    [Char]
sTime :: String <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"timestamp"
    [Char]
rTime :: String <- Object
redemption Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"redeemed_at"
    let serverTime :: Maybe UTCTime
serverTime = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
sTime
        redeemedTime :: Maybe UTCTime
redeemedTime = ZonedTime -> UTCTime
Time.zonedTimeToUTC (ZonedTime -> UTCTime) -> Maybe ZonedTime -> Maybe UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> Maybe ZonedTime
forall t. TextualMonoid t => t -> Maybe ZonedTime
Time.parseTimeRFC3339 [Char]
rTime

    Maybe [Char]
promptAnswer <- Object
redemption Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"user_input"
    Bool
promptEnabled :: Bool <- Object
reward Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_user_input_required"
    let userInput :: Maybe [Char]
userInput = if Bool
promptEnabled then Maybe [Char]
promptAnswer else Maybe [Char]
forall a. Maybe a
Nothing

    Object
maxObject <- Object
reward Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_per_stream"
    Bool
maxEnabled :: Bool <- Object
maxObject Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"is_enabled"
    Integer
maxCount <- Object
maxObject Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_per_stream"
    let maxPerStream :: Maybe Integer
maxPerStream = if Bool
maxEnabled then Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
maxCount else Maybe Integer
forall a. Maybe a
Nothing

    [Char]
status' <- Object
redemption Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status"
    let status :: RewardStatus
status = [Char] -> RewardStatus
forall a. Read a => [Char] -> a
read [Char]
status' :: RewardStatus

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ChannelPointsMessage{Bool
Integer
[Char]
Maybe Integer
Maybe [Char]
Maybe UTCTime
Maybe RewardImages
RewardStatus
UserInfo
RewardImages
channelId :: Integer
serverTime :: Maybe UTCTime
redeemedTime :: Maybe UTCTime
userInfo :: UserInfo
rewardId :: [Char]
title :: [Char]
prompt :: Maybe [Char]
cost :: Integer
userInput :: Maybe [Char]
subOnly :: Bool
image :: Maybe RewardImages
defaultImage :: RewardImages
backgroundColor :: [Char]
enabled :: Bool
paused :: Bool
inStock :: Bool
maxPerStream :: Maybe Integer
autoFulfilled :: Bool
status :: RewardStatus
userInfo :: UserInfo
rewardId :: [Char]
title :: [Char]
prompt :: Maybe [Char]
cost :: Integer
subOnly :: Bool
image :: Maybe RewardImages
defaultImage :: RewardImages
backgroundColor :: [Char]
enabled :: Bool
paused :: Bool
inStock :: Bool
autoFulfilled :: Bool
channelId :: Integer
serverTime :: Maybe UTCTime
redeemedTime :: Maybe UTCTime
userInput :: Maybe [Char]
maxPerStream :: Maybe Integer
status :: RewardStatus
..}

parseWhisperMessage :: MessageParser
parseWhisperMessage :: MessageParser
parseWhisperMessage Object
o = do
    Object
dat <- Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data_object"
    [Char]
messageId <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message_id"
    [Char]
threadId <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"thread_id"
    [Char]
messageBody <- Object
dat Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"body"
    Object
tags <- Object
dat Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tags"
    [EmoteSpec]
messageEmotes <- Object
tags Object -> Key -> Parser [EmoteSpec]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"emotes"
    [Char]
userColor <- Object
tags Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"color"

    Integer
messageUser <- Object
dat Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"from_id"
    [Char]
messageUserName <- Object
tags Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"login"
    Maybe [Char]
displayName <- Object
tags Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"display_name"
    let userInfo :: UserInfo
userInfo = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
messageUser [Char]
messageUserName Maybe [Char]
displayName

    Object
recipientData <- Object
dat Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"recipient"
    Integer
rUserId <- Object
recipientData Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
    [Char]
rUserName <- Object
recipientData Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"username"
    Maybe [Char]
rDisplayName <- Object
recipientData Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"display_name"
    let recipient :: UserInfo
recipient = Integer -> [Char] -> Maybe [Char] -> UserInfo
UserInfo Integer
rUserId [Char]
rUserName Maybe [Char]
rDisplayName

    Integer
timestamp :: Integer <- Object
dat Object -> Key -> Parser Integer
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sent_ts"
    let time :: Maybe UTCTime
time = UTCTime -> Maybe UTCTime
forall a. a -> Maybe a
Just (UTCTime -> Maybe UTCTime)
-> (POSIXTime -> UTCTime) -> POSIXTime -> Maybe UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> UTCTime
Time.posixSecondsToUTCTime (POSIXTime -> Maybe UTCTime) -> POSIXTime -> Maybe UTCTime
forall a b. (a -> b) -> a -> b
$ Integer -> POSIXTime
forall a b. (Real a, Fractional b) => a -> b
realToFrac Integer
timestamp

    Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return WhisperMessage{[Char]
[EmoteSpec]
Maybe UTCTime
UserInfo
messageId :: [Char]
time :: Maybe UTCTime
userInfo :: UserInfo
recipient :: UserInfo
threadId :: [Char]
messageBody :: [Char]
messageEmotes :: [EmoteSpec]
userColor :: [Char]
messageId :: [Char]
threadId :: [Char]
messageBody :: [Char]
messageEmotes :: [EmoteSpec]
userColor :: [Char]
userInfo :: UserInfo
recipient :: UserInfo
time :: Maybe UTCTime
..}

parseServerResponse :: MessageParser
parseServerResponse :: MessageParser
parseServerResponse Object
o = do
    [Char]
errorString <- Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"error"
    Maybe [Char]
nonce <- Object
o Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"nonce"
    if [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
errorString
       then Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return SuccessMessage{Maybe [Char]
nonce :: Maybe [Char]
nonce :: Maybe [Char]
..}
       else Message -> Parser Message
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ErrorMessage{[Char]
Maybe [Char]
nonce :: Maybe [Char]
errorString :: [Char]
errorString :: [Char]
nonce :: Maybe [Char]
..}

instance FromJSON Message where
    parseJSON :: Value -> Parser Message
parseJSON = [Char] -> MessageParser -> Value -> Parser Message
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
withObject [Char]
"Received" (MessageParser -> Value -> Parser Message)
-> MessageParser -> Value -> Parser Message
forall a b. (a -> b) -> a -> b
$ \Object
o -> do
        Object
o Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type" Parser [Char] -> ([Char] -> Parser Message) -> Parser Message
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char]
reportedType :: String) -> case [Char]
reportedType of
            [Char]
"RESPONSE" -> MessageParser
parseServerResponse Object
o
            [Char]
"MESSAGE" -> do
                Object
d <- Object
o Object -> Key -> Parser Object
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"data"
                Text
m <- Object
d Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message"
                Object
m' <- [Char] -> (Value -> Parser Object) -> Value -> Parser Object
forall a. [Char] -> (Value -> Parser a) -> Value -> Parser a
withEmbeddedJSON [Char]
"Message" Value -> Parser Object
forall a. FromJSON a => Value -> Parser a
parseJSON (Text -> Value
JSON.String Text
m)
                Object
m' Object -> Key -> Parser (Maybe [Char])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"type" Parser (Maybe [Char])
-> (Maybe [Char] -> Parser Message) -> Parser Message
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(Maybe [Char]
message :: Maybe String) ->
                    case Maybe [Char]
message of
                        Just [Char]
"reward-redeemed" -> MessageParser
parseRewardMessage Object
m'
                        Maybe [Char]
_ -> Object
d Object -> Key -> Parser [Char]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"topic" Parser [Char] -> ([Char] -> Parser Message) -> Parser Message
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([Char]
topic :: String) -> case (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'.') [Char]
topic of
                            [Char]
"channel-bits-badge-unlocks" -> MessageParser
parseBitsBadgeMessage Object
m'
                            [Char]
"channel-bits-events-v1" -> MessageParser
parseBitsV1Message Object
m'
                            [Char]
"channel-bits-events-v2" -> MessageParser
parseBitsV2Message Object
m'
                            [Char]
"channel-subscribe-events-v1" -> MessageParser
parseChannelSubscribeMessage Object
m'
                            [Char]
"whispers" -> MessageParser
parseWhisperMessage Object
m'
                            [Char]
_ -> Parser Message
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
            [Char]
_ -> Parser Message
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

--data ChatModeratorActionsMessage
--data WhispersMessage