{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}

module Simplex.Messaging.Notifications.Types
  ( NtfTknAction (..),
    NtfToken (..),
    NtfSubAction (..),
    NtfActionTs,
    NtfSubNTFAction (..),
    NtfSubSMPAction (..),
    NtfAgentSubStatus (..),
    NtfSubscription (..),
    newNtfToken,
    isDeleteNtfSubAction,
    newNtfSubscription,
  ) where

import qualified Data.Attoparsec.ByteString.Char8 as A
import Data.Text.Encoding (decodeLatin1, encodeUtf8)
import Data.Time (UTCTime)
import Simplex.Messaging.Agent.Protocol (ConnId, NotificationsMode (..), UserId)
import Simplex.Messaging.Agent.Store.DB (Binary (..), FromField (..), ToField (..), blobFieldDecoder, fromTextField_)
import qualified Simplex.Messaging.Crypto as C
import Simplex.Messaging.Encoding
import Simplex.Messaging.Encoding.String
import Simplex.Messaging.Notifications.Protocol
import Simplex.Messaging.Protocol (NotifierId, NtfServer, SMPServer)
import Simplex.Messaging.Util (eitherToMaybe)

data NtfTknAction
  = NTARegister
  | NTAVerify NtfRegCode -- code to verify token
  | NTACheck
  | NTADelete
  deriving (Int -> NtfTknAction -> ShowS
[NtfTknAction] -> ShowS
NtfTknAction -> String
(Int -> NtfTknAction -> ShowS)
-> (NtfTknAction -> String)
-> ([NtfTknAction] -> ShowS)
-> Show NtfTknAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NtfTknAction -> ShowS
showsPrec :: Int -> NtfTknAction -> ShowS
$cshow :: NtfTknAction -> String
show :: NtfTknAction -> String
$cshowList :: [NtfTknAction] -> ShowS
showList :: [NtfTknAction] -> ShowS
Show)

instance Encoding NtfTknAction where
  smpEncode :: NtfTknAction -> ByteString
smpEncode = \case
    NtfTknAction
NTARegister -> ByteString
"R"
    NTAVerify NtfRegCode
code -> (Char, NtfRegCode) -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode (Char
'V', NtfRegCode
code)
    NtfTknAction
NTACheck -> ByteString
"C"
    NtfTknAction
NTADelete -> ByteString
"D"
  smpP :: Parser NtfTknAction
smpP =
    Parser Char
A.anyChar Parser Char -> (Char -> Parser NtfTknAction) -> Parser NtfTknAction
forall a b.
Parser ByteString a
-> (a -> Parser ByteString b) -> Parser ByteString b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Char
'R' -> NtfTknAction -> Parser NtfTknAction
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NtfTknAction
NTARegister
      Char
'V' -> NtfRegCode -> NtfTknAction
NTAVerify (NtfRegCode -> NtfTknAction)
-> Parser ByteString NtfRegCode -> Parser NtfTknAction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString NtfRegCode
forall a. Encoding a => Parser a
smpP
      Char
'C' -> NtfTknAction -> Parser NtfTknAction
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NtfTknAction
NTACheck
      Char
'D' -> NtfTknAction -> Parser NtfTknAction
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NtfTknAction
NTADelete
      Char
_ -> String -> Parser NtfTknAction
forall a. String -> Parser ByteString a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad NtfTknAction"

instance FromField NtfTknAction where fromField :: FieldParser NtfTknAction
fromField = (ByteString -> Either String NtfTknAction)
-> FieldParser NtfTknAction
forall k.
Typeable k =>
(ByteString -> Either String k) -> FieldParser k
blobFieldDecoder ByteString -> Either String NtfTknAction
forall a. Encoding a => ByteString -> Either String a
smpDecode

instance ToField NtfTknAction where toField :: NtfTknAction -> SQLData
toField = Binary ByteString -> SQLData
forall a. ToField a => a -> SQLData
toField (Binary ByteString -> SQLData)
-> (NtfTknAction -> Binary ByteString) -> NtfTknAction -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Binary ByteString
forall a. a -> Binary a
Binary (ByteString -> Binary ByteString)
-> (NtfTknAction -> ByteString)
-> NtfTknAction
-> Binary ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NtfTknAction -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode

data NtfToken = NtfToken
  { NtfToken -> DeviceToken
deviceToken :: DeviceToken,
    NtfToken -> NtfServer
ntfServer :: NtfServer,
    NtfToken -> Maybe NtfTokenId
ntfTokenId :: Maybe NtfTokenId,
    -- TODO combine keys to key pair as the types should match

    -- | key used by the ntf server to verify transmissions
    NtfToken -> APublicAuthKey
ntfPubKey :: C.APublicAuthKey,
    -- | key used by the ntf client to sign transmissions
    NtfToken -> APrivateAuthKey
ntfPrivKey :: C.APrivateAuthKey,
    -- | client's DH keys (to repeat registration if necessary)
    NtfToken -> KeyPairX25519
ntfDhKeys :: C.KeyPairX25519,
    -- | shared DH secret used to encrypt/decrypt notifications e2e
    NtfToken -> Maybe DhSecretX25519
ntfDhSecret :: Maybe C.DhSecretX25519,
    -- | token status
    NtfToken -> NtfTknStatus
ntfTknStatus :: NtfTknStatus,
    -- | pending token action and the earliest time
    NtfToken -> Maybe NtfTknAction
ntfTknAction :: Maybe NtfTknAction,
    NtfToken -> NotificationsMode
ntfMode :: NotificationsMode
  }
  deriving (Int -> NtfToken -> ShowS
[NtfToken] -> ShowS
NtfToken -> String
(Int -> NtfToken -> ShowS)
-> (NtfToken -> String) -> ([NtfToken] -> ShowS) -> Show NtfToken
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NtfToken -> ShowS
showsPrec :: Int -> NtfToken -> ShowS
$cshow :: NtfToken -> String
show :: NtfToken -> String
$cshowList :: [NtfToken] -> ShowS
showList :: [NtfToken] -> ShowS
Show)

newNtfToken :: DeviceToken -> NtfServer -> C.AAuthKeyPair -> C.KeyPairX25519 -> NotificationsMode -> NtfToken
newNtfToken :: DeviceToken
-> NtfServer
-> AAuthKeyPair
-> KeyPairX25519
-> NotificationsMode
-> NtfToken
newNtfToken DeviceToken
deviceToken NtfServer
ntfServer (PublicKeyType APrivateAuthKey
ntfPubKey, APrivateAuthKey
ntfPrivKey) KeyPairX25519
ntfDhKeys NotificationsMode
ntfMode =
  NtfToken
    { DeviceToken
$sel:deviceToken:NtfToken :: DeviceToken
deviceToken :: DeviceToken
deviceToken,
      NtfServer
$sel:ntfServer:NtfToken :: NtfServer
ntfServer :: NtfServer
ntfServer,
      $sel:ntfTokenId:NtfToken :: Maybe NtfTokenId
ntfTokenId = Maybe NtfTokenId
forall a. Maybe a
Nothing,
      PublicKeyType APrivateAuthKey
APublicAuthKey
$sel:ntfPubKey:NtfToken :: APublicAuthKey
ntfPubKey :: PublicKeyType APrivateAuthKey
ntfPubKey,
      APrivateAuthKey
$sel:ntfPrivKey:NtfToken :: APrivateAuthKey
ntfPrivKey :: APrivateAuthKey
ntfPrivKey,
      KeyPairX25519
$sel:ntfDhKeys:NtfToken :: KeyPairX25519
ntfDhKeys :: KeyPairX25519
ntfDhKeys,
      $sel:ntfDhSecret:NtfToken :: Maybe DhSecretX25519
ntfDhSecret = Maybe DhSecretX25519
forall a. Maybe a
Nothing,
      $sel:ntfTknStatus:NtfToken :: NtfTknStatus
ntfTknStatus = NtfTknStatus
NTNew,
      $sel:ntfTknAction:NtfToken :: Maybe NtfTknAction
ntfTknAction = NtfTknAction -> Maybe NtfTknAction
forall a. a -> Maybe a
Just NtfTknAction
NTARegister,
      NotificationsMode
$sel:ntfMode:NtfToken :: NotificationsMode
ntfMode :: NotificationsMode
ntfMode
    }

data NtfSubAction = NSANtf NtfSubNTFAction | NSASMP NtfSubSMPAction
  deriving (Int -> NtfSubAction -> ShowS
[NtfSubAction] -> ShowS
NtfSubAction -> String
(Int -> NtfSubAction -> ShowS)
-> (NtfSubAction -> String)
-> ([NtfSubAction] -> ShowS)
-> Show NtfSubAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NtfSubAction -> ShowS
showsPrec :: Int -> NtfSubAction -> ShowS
$cshow :: NtfSubAction -> String
show :: NtfSubAction -> String
$cshowList :: [NtfSubAction] -> ShowS
showList :: [NtfSubAction] -> ShowS
Show)

isDeleteNtfSubAction :: NtfSubAction -> Bool
isDeleteNtfSubAction :: NtfSubAction -> Bool
isDeleteNtfSubAction = \case
  NSANtf NtfSubNTFAction
a -> case NtfSubNTFAction
a of
    NtfSubNTFAction
NSACreate -> Bool
False
    NtfSubNTFAction
NSACheck -> Bool
False
    NtfSubNTFAction
NSADelete -> Bool
True
    NtfSubNTFAction
NSARotate -> Bool
True
  NSASMP NtfSubSMPAction
a -> case NtfSubSMPAction
a of
    NtfSubSMPAction
NSASmpKey -> Bool
False
    NtfSubSMPAction
NSASmpDelete -> Bool
True

type NtfActionTs = UTCTime

data NtfSubNTFAction
  = NSACreate
  | NSACheck
  | NSADelete -- deprecated
  | NSARotate -- deprecated
  deriving (Int -> NtfSubNTFAction -> ShowS
[NtfSubNTFAction] -> ShowS
NtfSubNTFAction -> String
(Int -> NtfSubNTFAction -> ShowS)
-> (NtfSubNTFAction -> String)
-> ([NtfSubNTFAction] -> ShowS)
-> Show NtfSubNTFAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NtfSubNTFAction -> ShowS
showsPrec :: Int -> NtfSubNTFAction -> ShowS
$cshow :: NtfSubNTFAction -> String
show :: NtfSubNTFAction -> String
$cshowList :: [NtfSubNTFAction] -> ShowS
showList :: [NtfSubNTFAction] -> ShowS
Show)

instance TextEncoding NtfSubNTFAction where
  textEncode :: NtfSubNTFAction -> Text
textEncode = \case
    NtfSubNTFAction
NSACreate -> Text
"N"
    NtfSubNTFAction
NSACheck -> Text
"C"
    NtfSubNTFAction
NSADelete -> Text
"D"
    NtfSubNTFAction
NSARotate -> Text
"R"
  textDecode :: Text -> Maybe NtfSubNTFAction
textDecode = \case
    Text
"N" -> NtfSubNTFAction -> Maybe NtfSubNTFAction
forall a. a -> Maybe a
Just NtfSubNTFAction
NSACreate
    Text
"C" -> NtfSubNTFAction -> Maybe NtfSubNTFAction
forall a. a -> Maybe a
Just NtfSubNTFAction
NSACheck
    Text
"D" -> NtfSubNTFAction -> Maybe NtfSubNTFAction
forall a. a -> Maybe a
Just NtfSubNTFAction
NSADelete
    Text
"R" -> NtfSubNTFAction -> Maybe NtfSubNTFAction
forall a. a -> Maybe a
Just NtfSubNTFAction
NSARotate
    Text
_ -> Maybe NtfSubNTFAction
forall a. Maybe a
Nothing

instance FromField NtfSubNTFAction where fromField :: FieldParser NtfSubNTFAction
fromField = (Text -> Maybe NtfSubNTFAction) -> FieldParser NtfSubNTFAction
forall a. Typeable a => (Text -> Maybe a) -> Field -> Ok a
fromTextField_ Text -> Maybe NtfSubNTFAction
forall a. TextEncoding a => Text -> Maybe a
textDecode

instance ToField NtfSubNTFAction where toField :: NtfSubNTFAction -> SQLData
toField = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Text -> SQLData)
-> (NtfSubNTFAction -> Text) -> NtfSubNTFAction -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NtfSubNTFAction -> Text
forall a. TextEncoding a => a -> Text
textEncode

data NtfSubSMPAction
  = NSASmpKey
  | NSASmpDelete
  deriving (Int -> NtfSubSMPAction -> ShowS
[NtfSubSMPAction] -> ShowS
NtfSubSMPAction -> String
(Int -> NtfSubSMPAction -> ShowS)
-> (NtfSubSMPAction -> String)
-> ([NtfSubSMPAction] -> ShowS)
-> Show NtfSubSMPAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NtfSubSMPAction -> ShowS
showsPrec :: Int -> NtfSubSMPAction -> ShowS
$cshow :: NtfSubSMPAction -> String
show :: NtfSubSMPAction -> String
$cshowList :: [NtfSubSMPAction] -> ShowS
showList :: [NtfSubSMPAction] -> ShowS
Show)

instance TextEncoding NtfSubSMPAction where
  textEncode :: NtfSubSMPAction -> Text
textEncode = \case
    NtfSubSMPAction
NSASmpKey -> Text
"K"
    NtfSubSMPAction
NSASmpDelete -> Text
"D"
  textDecode :: Text -> Maybe NtfSubSMPAction
textDecode = \case
    Text
"K" -> NtfSubSMPAction -> Maybe NtfSubSMPAction
forall a. a -> Maybe a
Just NtfSubSMPAction
NSASmpKey
    Text
"D" -> NtfSubSMPAction -> Maybe NtfSubSMPAction
forall a. a -> Maybe a
Just NtfSubSMPAction
NSASmpDelete
    Text
_ -> Maybe NtfSubSMPAction
forall a. Maybe a
Nothing

instance FromField NtfSubSMPAction where fromField :: FieldParser NtfSubSMPAction
fromField = (Text -> Maybe NtfSubSMPAction) -> FieldParser NtfSubSMPAction
forall a. Typeable a => (Text -> Maybe a) -> Field -> Ok a
fromTextField_ Text -> Maybe NtfSubSMPAction
forall a. TextEncoding a => Text -> Maybe a
textDecode

instance ToField NtfSubSMPAction where toField :: NtfSubSMPAction -> SQLData
toField = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Text -> SQLData)
-> (NtfSubSMPAction -> Text) -> NtfSubSMPAction -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NtfSubSMPAction -> Text
forall a. TextEncoding a => a -> Text
textEncode

data NtfAgentSubStatus
  = -- | subscription started
    NASNew
  | -- | state after NKEY - notifier ID is assigned to queue on SMP server
    NASKey
  | -- | state after SNEW - subscription created on notification server
    NASCreated NtfSubStatus
  | -- | state after SDEL (subscription is deleted on notification server)
    NASOff
  | -- | state after NDEL (notifier credentials are deleted on SMP server)
    -- Can only exist transiently - if subscription record was updated by notification supervisor mid worker operation,
    -- and hence got updated instead of being fully deleted in the database post operation by worker
    NASDeleted
  deriving (NtfAgentSubStatus -> NtfAgentSubStatus -> Bool
(NtfAgentSubStatus -> NtfAgentSubStatus -> Bool)
-> (NtfAgentSubStatus -> NtfAgentSubStatus -> Bool)
-> Eq NtfAgentSubStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NtfAgentSubStatus -> NtfAgentSubStatus -> Bool
== :: NtfAgentSubStatus -> NtfAgentSubStatus -> Bool
$c/= :: NtfAgentSubStatus -> NtfAgentSubStatus -> Bool
/= :: NtfAgentSubStatus -> NtfAgentSubStatus -> Bool
Eq, Int -> NtfAgentSubStatus -> ShowS
[NtfAgentSubStatus] -> ShowS
NtfAgentSubStatus -> String
(Int -> NtfAgentSubStatus -> ShowS)
-> (NtfAgentSubStatus -> String)
-> ([NtfAgentSubStatus] -> ShowS)
-> Show NtfAgentSubStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NtfAgentSubStatus -> ShowS
showsPrec :: Int -> NtfAgentSubStatus -> ShowS
$cshow :: NtfAgentSubStatus -> String
show :: NtfAgentSubStatus -> String
$cshowList :: [NtfAgentSubStatus] -> ShowS
showList :: [NtfAgentSubStatus] -> ShowS
Show)

instance Encoding NtfAgentSubStatus where
  smpEncode :: NtfAgentSubStatus -> ByteString
smpEncode = \case
    NtfAgentSubStatus
NASNew -> ByteString
"NEW"
    NtfAgentSubStatus
NASKey -> ByteString
"KEY"
    NASCreated NtfSubStatus
status -> ByteString
"CREATED " ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> NtfSubStatus -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode NtfSubStatus
status
    NtfAgentSubStatus
NASOff -> ByteString
"OFF"
    NtfAgentSubStatus
NASDeleted -> ByteString
"DELETED"
  smpP :: Parser NtfAgentSubStatus
smpP =
    (Char -> Bool) -> Parser ByteString
A.takeTill (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ') Parser ByteString
-> (ByteString -> Parser NtfAgentSubStatus)
-> Parser NtfAgentSubStatus
forall a b.
Parser ByteString a
-> (a -> Parser ByteString b) -> Parser ByteString b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      ByteString
"NEW" -> NtfAgentSubStatus -> Parser NtfAgentSubStatus
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NtfAgentSubStatus
NASNew
      ByteString
"KEY" -> NtfAgentSubStatus -> Parser NtfAgentSubStatus
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NtfAgentSubStatus
NASKey
      ByteString
"CREATED" -> do
        Char
_ <- Parser Char
A.space
        NtfSubStatus -> NtfAgentSubStatus
NASCreated (NtfSubStatus -> NtfAgentSubStatus)
-> Parser ByteString NtfSubStatus -> Parser NtfAgentSubStatus
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString NtfSubStatus
forall a. Encoding a => Parser a
smpP
      ByteString
"OFF" -> NtfAgentSubStatus -> Parser NtfAgentSubStatus
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NtfAgentSubStatus
NASOff
      ByteString
"DELETED" -> NtfAgentSubStatus -> Parser NtfAgentSubStatus
forall a. a -> Parser ByteString a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NtfAgentSubStatus
NASDeleted
      ByteString
_ -> String -> Parser NtfAgentSubStatus
forall a. String -> Parser ByteString a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad NtfAgentSubStatus"

instance FromField NtfAgentSubStatus where fromField :: FieldParser NtfAgentSubStatus
fromField = (Text -> Maybe NtfAgentSubStatus) -> FieldParser NtfAgentSubStatus
forall a. Typeable a => (Text -> Maybe a) -> Field -> Ok a
fromTextField_ ((Text -> Maybe NtfAgentSubStatus)
 -> FieldParser NtfAgentSubStatus)
-> (Text -> Maybe NtfAgentSubStatus)
-> FieldParser NtfAgentSubStatus
forall a b. (a -> b) -> a -> b
$ Either String NtfAgentSubStatus -> Maybe NtfAgentSubStatus
forall a b. Either a b -> Maybe b
eitherToMaybe (Either String NtfAgentSubStatus -> Maybe NtfAgentSubStatus)
-> (Text -> Either String NtfAgentSubStatus)
-> Text
-> Maybe NtfAgentSubStatus
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either String NtfAgentSubStatus
forall a. Encoding a => ByteString -> Either String a
smpDecode (ByteString -> Either String NtfAgentSubStatus)
-> (Text -> ByteString) -> Text -> Either String NtfAgentSubStatus
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
encodeUtf8

instance ToField NtfAgentSubStatus where toField :: NtfAgentSubStatus -> SQLData
toField = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Text -> SQLData)
-> (NtfAgentSubStatus -> Text) -> NtfAgentSubStatus -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Text
decodeLatin1 (ByteString -> Text)
-> (NtfAgentSubStatus -> ByteString) -> NtfAgentSubStatus -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NtfAgentSubStatus -> ByteString
forall a. Encoding a => a -> ByteString
smpEncode

data NtfSubscription = NtfSubscription
  { NtfSubscription -> UserId
userId :: UserId,
    NtfSubscription -> ByteString
connId :: ConnId,
    NtfSubscription -> SMPServer
smpServer :: SMPServer,
    NtfSubscription -> Maybe NtfTokenId
ntfQueueId :: Maybe NotifierId,
    NtfSubscription -> NtfServer
ntfServer :: NtfServer,
    NtfSubscription -> Maybe NtfTokenId
ntfSubId :: Maybe NtfSubscriptionId,
    NtfSubscription -> NtfAgentSubStatus
ntfSubStatus :: NtfAgentSubStatus
  }
  deriving (Int -> NtfSubscription -> ShowS
[NtfSubscription] -> ShowS
NtfSubscription -> String
(Int -> NtfSubscription -> ShowS)
-> (NtfSubscription -> String)
-> ([NtfSubscription] -> ShowS)
-> Show NtfSubscription
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NtfSubscription -> ShowS
showsPrec :: Int -> NtfSubscription -> ShowS
$cshow :: NtfSubscription -> String
show :: NtfSubscription -> String
$cshowList :: [NtfSubscription] -> ShowS
showList :: [NtfSubscription] -> ShowS
Show)

newNtfSubscription :: UserId -> ConnId -> SMPServer -> Maybe NotifierId -> NtfServer -> NtfAgentSubStatus -> NtfSubscription
newNtfSubscription :: UserId
-> ByteString
-> SMPServer
-> Maybe NtfTokenId
-> NtfServer
-> NtfAgentSubStatus
-> NtfSubscription
newNtfSubscription UserId
userId ByteString
connId SMPServer
smpServer Maybe NtfTokenId
ntfQueueId NtfServer
ntfServer NtfAgentSubStatus
ntfSubStatus =
  NtfSubscription
    { UserId
$sel:userId:NtfSubscription :: UserId
userId :: UserId
userId,
      ByteString
$sel:connId:NtfSubscription :: ByteString
connId :: ByteString
connId,
      SMPServer
$sel:smpServer:NtfSubscription :: SMPServer
smpServer :: SMPServer
smpServer,
      Maybe NtfTokenId
$sel:ntfQueueId:NtfSubscription :: Maybe NtfTokenId
ntfQueueId :: Maybe NtfTokenId
ntfQueueId,
      NtfServer
$sel:ntfServer:NtfSubscription :: NtfServer
ntfServer :: NtfServer
ntfServer,
      $sel:ntfSubId:NtfSubscription :: Maybe NtfTokenId
ntfSubId = Maybe NtfTokenId
forall a. Maybe a
Nothing,
      NtfAgentSubStatus
$sel:ntfSubStatus:NtfSubscription :: NtfAgentSubStatus
ntfSubStatus :: NtfAgentSubStatus
ntfSubStatus
    }