{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilyDependencies #-}
{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
{-# OPTIONS_GHC -fno-warn-ambiguous-fields #-}

{-# HLINT ignore "Use newtype instead of data" #-}

module Simplex.Chat.Types.Preferences where

import Control.Applicative ((<|>))
import Data.Aeson (FromJSON (..), ToJSON (..))
import qualified Data.Aeson.TH as J
import qualified Data.Attoparsec.ByteString.Char8 as A
import qualified Data.ByteString.Char8 as B
import Data.Maybe (fromMaybe, isJust)
import Data.Text (Text)
import qualified Data.Text as T
import GHC.Records.Compat
import Simplex.Chat.Options.DB (FromField (..), ToField (..))
import Simplex.Chat.Types.Shared
import Simplex.Messaging.Agent.Store.DB (blobFieldDecoder, fromTextField_)
import Simplex.Messaging.Encoding.String
import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, enumJSON, sumTypeJSON, taggedObjectJSON)
import Simplex.Messaging.Util (decodeJSON, encodeJSON, safeDecodeUtf8, (<$?>))

data ChatFeature
  = CFTimedMessages
  | CFFullDelete
  | CFReactions
  | CFVoice
  | CFFiles
  | CFCalls
  | CFSessions
  deriving (Int -> ChatFeature -> ShowS
[ChatFeature] -> ShowS
ChatFeature -> String
(Int -> ChatFeature -> ShowS)
-> (ChatFeature -> String)
-> ([ChatFeature] -> ShowS)
-> Show ChatFeature
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChatFeature -> ShowS
showsPrec :: Int -> ChatFeature -> ShowS
$cshow :: ChatFeature -> String
show :: ChatFeature -> String
$cshowList :: [ChatFeature] -> ShowS
showList :: [ChatFeature] -> ShowS
Show)

data SChatFeature (f :: ChatFeature) where
  SCFTimedMessages :: SChatFeature 'CFTimedMessages
  SCFFullDelete :: SChatFeature 'CFFullDelete
  SCFReactions :: SChatFeature 'CFReactions
  SCFVoice :: SChatFeature 'CFVoice
  SCFFiles :: SChatFeature 'CFFiles
  SCFCalls :: SChatFeature 'CFCalls
  SCFSessions :: SChatFeature 'CFSessions

deriving instance Show (SChatFeature f)

data AChatFeature = forall f. FeatureI f => ACF (SChatFeature f)

deriving instance Show AChatFeature

chatFeatureNameText :: ChatFeature -> Text
chatFeatureNameText :: ChatFeature -> Text
chatFeatureNameText = \case
  ChatFeature
CFTimedMessages -> Text
"Disappearing messages"
  ChatFeature
CFFullDelete -> Text
"Full deletion"
  ChatFeature
CFReactions -> Text
"Message reactions"
  ChatFeature
CFVoice -> Text
"Voice messages"
  ChatFeature
CFFiles -> Text
"Files and media"
  ChatFeature
CFCalls -> Text
"Audio/video calls"
  ChatFeature
CFSessions -> Text
"Chat sessions"

chatFeatureNameText' :: SChatFeature f -> Text
chatFeatureNameText' :: forall (f :: ChatFeature). SChatFeature f -> Text
chatFeatureNameText' = ChatFeature -> Text
chatFeatureNameText (ChatFeature -> Text)
-> (SChatFeature f -> ChatFeature) -> SChatFeature f -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SChatFeature f -> ChatFeature
forall (f :: ChatFeature). SChatFeature f -> ChatFeature
chatFeature

allChatFeatures :: [AChatFeature]
allChatFeatures :: [AChatFeature]
allChatFeatures =
  [ SChatFeature 'CFTimedMessages -> AChatFeature
forall (f :: ChatFeature).
FeatureI f =>
SChatFeature f -> AChatFeature
ACF SChatFeature 'CFTimedMessages
SCFTimedMessages,
    SChatFeature 'CFFullDelete -> AChatFeature
forall (f :: ChatFeature).
FeatureI f =>
SChatFeature f -> AChatFeature
ACF SChatFeature 'CFFullDelete
SCFFullDelete,
    SChatFeature 'CFReactions -> AChatFeature
forall (f :: ChatFeature).
FeatureI f =>
SChatFeature f -> AChatFeature
ACF SChatFeature 'CFReactions
SCFReactions,
    SChatFeature 'CFVoice -> AChatFeature
forall (f :: ChatFeature).
FeatureI f =>
SChatFeature f -> AChatFeature
ACF SChatFeature 'CFVoice
SCFVoice,
    -- ACF SCFFiles, -- not showing in the UI
    SChatFeature 'CFCalls -> AChatFeature
forall (f :: ChatFeature).
FeatureI f =>
SChatFeature f -> AChatFeature
ACF SChatFeature 'CFCalls
SCFCalls
    -- ACF SCFSessions -- not showing in the UI
  ]

chatPrefSel :: SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
chatPrefSel :: forall (f :: ChatFeature).
SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
chatPrefSel SChatFeature f
f Preferences {Maybe TimedMessagesPreference
timedMessages :: Maybe TimedMessagesPreference
timedMessages :: Preferences -> Maybe TimedMessagesPreference
timedMessages, Maybe FullDeletePreference
fullDelete :: Maybe FullDeletePreference
fullDelete :: Preferences -> Maybe FullDeletePreference
fullDelete, Maybe ReactionsPreference
reactions :: Maybe ReactionsPreference
reactions :: Preferences -> Maybe ReactionsPreference
reactions, Maybe VoicePreference
voice :: Maybe VoicePreference
voice :: Preferences -> Maybe VoicePreference
voice, Maybe FilesPreference
files :: Maybe FilesPreference
files :: Preferences -> Maybe FilesPreference
files, Maybe CallsPreference
calls :: Maybe CallsPreference
calls :: Preferences -> Maybe CallsPreference
calls, Maybe SessionsPreference
sessions :: Maybe SessionsPreference
sessions :: Preferences -> Maybe SessionsPreference
sessions} = case SChatFeature f
f of
  SChatFeature f
SCFTimedMessages -> Maybe (FeaturePreference f)
Maybe TimedMessagesPreference
timedMessages
  SChatFeature f
SCFFullDelete -> Maybe (FeaturePreference f)
Maybe FullDeletePreference
fullDelete
  SChatFeature f
SCFReactions -> Maybe (FeaturePreference f)
Maybe ReactionsPreference
reactions
  SChatFeature f
SCFVoice -> Maybe (FeaturePreference f)
Maybe VoicePreference
voice
  SChatFeature f
SCFFiles -> Maybe (FeaturePreference f)
Maybe FilesPreference
files
  SChatFeature f
SCFCalls -> Maybe (FeaturePreference f)
Maybe CallsPreference
calls
  SChatFeature f
SCFSessions -> Maybe (FeaturePreference f)
Maybe SessionsPreference
sessions

chatFeature :: SChatFeature f -> ChatFeature
chatFeature :: forall (f :: ChatFeature). SChatFeature f -> ChatFeature
chatFeature = \case
  SChatFeature f
SCFTimedMessages -> ChatFeature
CFTimedMessages
  SChatFeature f
SCFFullDelete -> ChatFeature
CFFullDelete
  SChatFeature f
SCFReactions -> ChatFeature
CFReactions
  SChatFeature f
SCFVoice -> ChatFeature
CFVoice
  SChatFeature f
SCFFiles -> ChatFeature
CFFiles
  SChatFeature f
SCFCalls -> ChatFeature
CFCalls
  SChatFeature f
SCFSessions -> ChatFeature
CFSessions

class PreferenceI p where
  getPreference :: SChatFeature f -> p -> FeaturePreference f

instance PreferenceI Preferences where
  getPreference :: forall (f :: ChatFeature).
SChatFeature f -> Preferences -> FeaturePreference f
getPreference SChatFeature f
f Preferences
prefs = FeaturePreference f
-> Maybe (FeaturePreference f) -> FeaturePreference f
forall a. a -> Maybe a -> a
fromMaybe (SChatFeature f -> FullPreferences -> FeaturePreference f
forall p (f :: ChatFeature).
PreferenceI p =>
SChatFeature f -> p -> FeaturePreference f
forall (f :: ChatFeature).
SChatFeature f -> FullPreferences -> FeaturePreference f
getPreference SChatFeature f
f FullPreferences
defaultChatPrefs) (SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
forall (f :: ChatFeature).
SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
chatPrefSel SChatFeature f
f Preferences
prefs)

instance PreferenceI (Maybe Preferences) where
  getPreference :: forall (f :: ChatFeature).
SChatFeature f -> Maybe Preferences -> FeaturePreference f
getPreference SChatFeature f
f Maybe Preferences
prefs = FeaturePreference f
-> Maybe (FeaturePreference f) -> FeaturePreference f
forall a. a -> Maybe a -> a
fromMaybe (SChatFeature f -> FullPreferences -> FeaturePreference f
forall p (f :: ChatFeature).
PreferenceI p =>
SChatFeature f -> p -> FeaturePreference f
forall (f :: ChatFeature).
SChatFeature f -> FullPreferences -> FeaturePreference f
getPreference SChatFeature f
f FullPreferences
defaultChatPrefs) (SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
forall (f :: ChatFeature).
SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
chatPrefSel SChatFeature f
f (Preferences -> Maybe (FeaturePreference f))
-> Maybe Preferences -> Maybe (FeaturePreference f)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe Preferences
prefs)

instance PreferenceI FullPreferences where
  getPreference :: forall (f :: ChatFeature).
SChatFeature f -> FullPreferences -> FeaturePreference f
getPreference SChatFeature f
f FullPreferences {TimedMessagesPreference
timedMessages :: TimedMessagesPreference
timedMessages :: FullPreferences -> TimedMessagesPreference
timedMessages, FullDeletePreference
fullDelete :: FullDeletePreference
fullDelete :: FullPreferences -> FullDeletePreference
fullDelete, ReactionsPreference
reactions :: ReactionsPreference
reactions :: FullPreferences -> ReactionsPreference
reactions, VoicePreference
voice :: VoicePreference
voice :: FullPreferences -> VoicePreference
voice, FilesPreference
files :: FilesPreference
files :: FullPreferences -> FilesPreference
files, CallsPreference
calls :: CallsPreference
calls :: FullPreferences -> CallsPreference
calls, SessionsPreference
sessions :: SessionsPreference
sessions :: FullPreferences -> SessionsPreference
sessions} = case SChatFeature f
f of
    SChatFeature f
SCFTimedMessages -> FeaturePreference f
TimedMessagesPreference
timedMessages
    SChatFeature f
SCFFullDelete -> FeaturePreference f
FullDeletePreference
fullDelete
    SChatFeature f
SCFReactions -> FeaturePreference f
ReactionsPreference
reactions
    SChatFeature f
SCFVoice -> FeaturePreference f
VoicePreference
voice
    SChatFeature f
SCFFiles -> FeaturePreference f
FilesPreference
files
    SChatFeature f
SCFCalls -> FeaturePreference f
CallsPreference
calls
    SChatFeature f
SCFSessions -> FeaturePreference f
SessionsPreference
sessions
  {-# INLINE getPreference #-}

setPreference :: forall f. FeatureI f => SChatFeature f -> Maybe FeatureAllowed -> Maybe Preferences -> Preferences
setPreference :: forall (f :: ChatFeature).
FeatureI f =>
SChatFeature f
-> Maybe FeatureAllowed -> Maybe Preferences -> Preferences
setPreference SChatFeature f
f Maybe FeatureAllowed
allow_ Maybe Preferences
prefs_ = SChatFeature f
-> Maybe (FeaturePreference f) -> Preferences -> Preferences
forall (f :: ChatFeature).
SChatFeature f
-> Maybe (FeaturePreference f) -> Preferences -> Preferences
setPreference_ SChatFeature f
f Maybe (FeaturePreference f)
pref (Preferences -> Preferences) -> Preferences -> Preferences
forall a b. (a -> b) -> a -> b
$ Preferences -> Maybe Preferences -> Preferences
forall a. a -> Maybe a -> a
fromMaybe Preferences
emptyChatPrefs Maybe Preferences
prefs_
  where
    pref :: Maybe (FeaturePreference f)
pref = FeatureAllowed -> FeaturePreference f
setAllow (FeatureAllowed -> FeaturePreference f)
-> Maybe FeatureAllowed -> Maybe (FeaturePreference f)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe FeatureAllowed
allow_
    setAllow :: FeatureAllowed -> FeaturePreference f
    setAllow :: FeatureAllowed -> FeaturePreference f
setAllow = forall {k} (x :: k) r a. HasField x r a => r -> a -> r
forall (x :: Symbol) r a. HasField x r a => r -> a -> r
setField @"allow" (SChatFeature f -> Maybe Preferences -> FeaturePreference f
forall p (f :: ChatFeature).
PreferenceI p =>
SChatFeature f -> p -> FeaturePreference f
forall (f :: ChatFeature).
SChatFeature f -> Maybe Preferences -> FeaturePreference f
getPreference SChatFeature f
f Maybe Preferences
prefs_)

setPreference' :: SChatFeature f -> Maybe (FeaturePreference f) -> Maybe Preferences -> Preferences
setPreference' :: forall (f :: ChatFeature).
SChatFeature f
-> Maybe (FeaturePreference f) -> Maybe Preferences -> Preferences
setPreference' SChatFeature f
f Maybe (FeaturePreference f)
pref_ Maybe Preferences
prefs_ = SChatFeature f
-> Maybe (FeaturePreference f) -> Preferences -> Preferences
forall (f :: ChatFeature).
SChatFeature f
-> Maybe (FeaturePreference f) -> Preferences -> Preferences
setPreference_ SChatFeature f
f Maybe (FeaturePreference f)
pref_ (Preferences -> Preferences) -> Preferences -> Preferences
forall a b. (a -> b) -> a -> b
$ Preferences -> Maybe Preferences -> Preferences
forall a. a -> Maybe a -> a
fromMaybe Preferences
emptyChatPrefs Maybe Preferences
prefs_

setPreference_ :: SChatFeature f -> Maybe (FeaturePreference f) -> Preferences -> Preferences
setPreference_ :: forall (f :: ChatFeature).
SChatFeature f
-> Maybe (FeaturePreference f) -> Preferences -> Preferences
setPreference_ SChatFeature f
f Maybe (FeaturePreference f)
pref_ Preferences
prefs =
  case SChatFeature f
f of
    SChatFeature f
SCFTimedMessages -> Preferences
prefs {timedMessages = pref_}
    SChatFeature f
SCFFullDelete -> Preferences
prefs {fullDelete = pref_}
    SChatFeature f
SCFReactions -> Preferences
prefs {reactions = pref_}
    SChatFeature f
SCFVoice -> Preferences
prefs {voice = pref_}
    SChatFeature f
SCFFiles -> Preferences
prefs {files = pref_}
    SChatFeature f
SCFCalls -> Preferences
prefs {calls = pref_}
    SChatFeature f
SCFSessions -> Preferences
prefs {sessions = pref_}

-- collection of optional chat preferences for the user and the contact
data Preferences = Preferences
  { Preferences -> Maybe TimedMessagesPreference
timedMessages :: Maybe TimedMessagesPreference,
    Preferences -> Maybe FullDeletePreference
fullDelete :: Maybe FullDeletePreference,
    Preferences -> Maybe ReactionsPreference
reactions :: Maybe ReactionsPreference,
    Preferences -> Maybe VoicePreference
voice :: Maybe VoicePreference,
    Preferences -> Maybe FilesPreference
files :: Maybe FilesPreference,
    Preferences -> Maybe CallsPreference
calls :: Maybe CallsPreference,
    Preferences -> Maybe SessionsPreference
sessions :: Maybe SessionsPreference,
    Preferences -> Maybe [ChatBotCommand]
commands :: Maybe [ChatBotCommand]
  }
  deriving (Preferences -> Preferences -> Bool
(Preferences -> Preferences -> Bool)
-> (Preferences -> Preferences -> Bool) -> Eq Preferences
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Preferences -> Preferences -> Bool
== :: Preferences -> Preferences -> Bool
$c/= :: Preferences -> Preferences -> Bool
/= :: Preferences -> Preferences -> Bool
Eq, Int -> Preferences -> ShowS
[Preferences] -> ShowS
Preferences -> String
(Int -> Preferences -> ShowS)
-> (Preferences -> String)
-> ([Preferences] -> ShowS)
-> Show Preferences
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Preferences -> ShowS
showsPrec :: Int -> Preferences -> ShowS
$cshow :: Preferences -> String
show :: Preferences -> String
$cshowList :: [Preferences] -> ShowS
showList :: [Preferences] -> ShowS
Show)

class HasCommands p where commands_ :: p -> Maybe [ChatBotCommand]

instance HasCommands Preferences where commands_ :: Preferences -> Maybe [ChatBotCommand]
commands_ Preferences {Maybe [ChatBotCommand]
commands :: Preferences -> Maybe [ChatBotCommand]
commands :: Maybe [ChatBotCommand]
commands} = Maybe [ChatBotCommand]
commands

data GroupFeature
  = GFTimedMessages
  | GFDirectMessages
  | GFFullDelete
  | GFReactions
  | GFVoice
  | GFFiles
  | GFSimplexLinks
  | GFReports
  | GFHistory
  | GFSessions
  deriving (Int -> GroupFeature -> ShowS
[GroupFeature] -> ShowS
GroupFeature -> String
(Int -> GroupFeature -> ShowS)
-> (GroupFeature -> String)
-> ([GroupFeature] -> ShowS)
-> Show GroupFeature
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupFeature -> ShowS
showsPrec :: Int -> GroupFeature -> ShowS
$cshow :: GroupFeature -> String
show :: GroupFeature -> String
$cshowList :: [GroupFeature] -> ShowS
showList :: [GroupFeature] -> ShowS
Show)

data SGroupFeature (f :: GroupFeature) where
  SGFTimedMessages :: SGroupFeature 'GFTimedMessages
  SGFDirectMessages :: SGroupFeature 'GFDirectMessages
  SGFFullDelete :: SGroupFeature 'GFFullDelete
  SGFReactions :: SGroupFeature 'GFReactions
  SGFVoice :: SGroupFeature 'GFVoice
  SGFFiles :: SGroupFeature 'GFFiles
  SGFSimplexLinks :: SGroupFeature 'GFSimplexLinks
  SGFReports :: SGroupFeature 'GFReports
  SGFHistory :: SGroupFeature 'GFHistory
  SGFSessions :: SGroupFeature 'GFSessions

deriving instance Show (SGroupFeature f)

data AGroupFeature = forall f. GroupFeatureI f => AGF (SGroupFeature f)

data AGroupFeatureNoRole = forall f. GroupFeatureNoRoleI f => AGFNR (SGroupFeature f)

data AGroupFeatureRole = forall f. GroupFeatureRoleI f => AGFR (SGroupFeature f)

deriving instance Show AGroupFeature

deriving instance Show AGroupFeatureNoRole

deriving instance Show AGroupFeatureRole

groupFeatureNameText :: GroupFeature -> Text
groupFeatureNameText :: GroupFeature -> Text
groupFeatureNameText = \case
  GroupFeature
GFTimedMessages -> Text
"Disappearing messages"
  GroupFeature
GFDirectMessages -> Text
"Direct messages"
  GroupFeature
GFFullDelete -> Text
"Full deletion"
  GroupFeature
GFReactions -> Text
"Message reactions"
  GroupFeature
GFVoice -> Text
"Voice messages"
  GroupFeature
GFFiles -> Text
"Files and media"
  GroupFeature
GFSimplexLinks -> Text
"SimpleX links"
  GroupFeature
GFReports -> Text
"Member reports"
  GroupFeature
GFHistory -> Text
"Recent history"
  GroupFeature
GFSessions -> Text
"Chat sessions"

groupFeatureNameText' :: SGroupFeature f -> Text
groupFeatureNameText' :: forall (f :: GroupFeature). SGroupFeature f -> Text
groupFeatureNameText' = GroupFeature -> Text
groupFeatureNameText (GroupFeature -> Text)
-> (SGroupFeature f -> GroupFeature) -> SGroupFeature f -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SGroupFeature f -> GroupFeature
forall (f :: GroupFeature). SGroupFeature f -> GroupFeature
toGroupFeature

groupFeatureAllowed' :: GroupFeatureNoRoleI f => SGroupFeature f -> FullGroupPreferences -> Bool
groupFeatureAllowed' :: forall (f :: GroupFeature).
GroupFeatureNoRoleI f =>
SGroupFeature f -> FullGroupPreferences -> Bool
groupFeatureAllowed' SGroupFeature f
feature FullGroupPreferences
prefs =
  forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"enable" (SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
feature FullGroupPreferences
prefs) GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
forall a. Eq a => a -> a -> Bool
== GroupFeatureEnabled
FEOn

groupFeatureMemberAllowed' :: GroupFeatureRoleI f => SGroupFeature f -> GroupMemberRole -> FullGroupPreferences -> Bool
groupFeatureMemberAllowed' :: forall (f :: GroupFeature).
GroupFeatureRoleI f =>
SGroupFeature f -> GroupMemberRole -> FullGroupPreferences -> Bool
groupFeatureMemberAllowed' SGroupFeature f
feature GroupMemberRole
role FullGroupPreferences
prefs =
  let pref :: GroupFeaturePreference f
pref = SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
feature FullGroupPreferences
prefs
   in forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"enable" GroupFeaturePreference f
pref GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
forall a. Eq a => a -> a -> Bool
== GroupFeatureEnabled
FEOn Bool -> Bool -> Bool
&& Bool -> (GroupMemberRole -> Bool) -> Maybe GroupMemberRole -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (GroupMemberRole
role GroupMemberRole -> GroupMemberRole -> Bool
forall a. Ord a => a -> a -> Bool
>=) (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"role" GroupFeaturePreference f
pref)

allGroupFeatures :: [AGroupFeature]
allGroupFeatures :: [AGroupFeature]
allGroupFeatures =
  [ SGroupFeature 'GFTimedMessages -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFTimedMessages
SGFTimedMessages,
    SGroupFeature 'GFDirectMessages -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFDirectMessages
SGFDirectMessages,
    SGroupFeature 'GFFullDelete -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFFullDelete
SGFFullDelete,
    SGroupFeature 'GFReactions -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFReactions
SGFReactions,
    SGroupFeature 'GFVoice -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFVoice
SGFVoice,
    SGroupFeature 'GFFiles -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFFiles
SGFFiles,
    SGroupFeature 'GFSimplexLinks -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFSimplexLinks
SGFSimplexLinks,
    SGroupFeature 'GFReports -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFReports
SGFReports,
    SGroupFeature 'GFHistory -> AGroupFeature
forall (f :: GroupFeature).
GroupFeatureI f =>
SGroupFeature f -> AGroupFeature
AGF SGroupFeature 'GFHistory
SGFHistory
  ]

groupPrefSel :: SGroupFeature f -> GroupPreferences -> Maybe (GroupFeaturePreference f)
groupPrefSel :: forall (f :: GroupFeature).
SGroupFeature f
-> GroupPreferences -> Maybe (GroupFeaturePreference f)
groupPrefSel SGroupFeature f
f GroupPreferences {Maybe TimedMessagesGroupPreference
timedMessages :: Maybe TimedMessagesGroupPreference
timedMessages :: GroupPreferences -> Maybe TimedMessagesGroupPreference
timedMessages, Maybe DirectMessagesGroupPreference
directMessages :: Maybe DirectMessagesGroupPreference
directMessages :: GroupPreferences -> Maybe DirectMessagesGroupPreference
directMessages, Maybe FullDeleteGroupPreference
fullDelete :: Maybe FullDeleteGroupPreference
fullDelete :: GroupPreferences -> Maybe FullDeleteGroupPreference
fullDelete, Maybe ReactionsGroupPreference
reactions :: Maybe ReactionsGroupPreference
reactions :: GroupPreferences -> Maybe ReactionsGroupPreference
reactions, Maybe VoiceGroupPreference
voice :: Maybe VoiceGroupPreference
voice :: GroupPreferences -> Maybe VoiceGroupPreference
voice, Maybe FilesGroupPreference
files :: Maybe FilesGroupPreference
files :: GroupPreferences -> Maybe FilesGroupPreference
files, Maybe SimplexLinksGroupPreference
simplexLinks :: Maybe SimplexLinksGroupPreference
simplexLinks :: GroupPreferences -> Maybe SimplexLinksGroupPreference
simplexLinks, Maybe ReportsGroupPreference
reports :: Maybe ReportsGroupPreference
reports :: GroupPreferences -> Maybe ReportsGroupPreference
reports, Maybe HistoryGroupPreference
history :: Maybe HistoryGroupPreference
history :: GroupPreferences -> Maybe HistoryGroupPreference
history, Maybe SessionsGroupPreference
sessions :: Maybe SessionsGroupPreference
sessions :: GroupPreferences -> Maybe SessionsGroupPreference
sessions} = case SGroupFeature f
f of
  SGroupFeature f
SGFTimedMessages -> Maybe (GroupFeaturePreference f)
Maybe TimedMessagesGroupPreference
timedMessages
  SGroupFeature f
SGFDirectMessages -> Maybe (GroupFeaturePreference f)
Maybe DirectMessagesGroupPreference
directMessages
  SGroupFeature f
SGFFullDelete -> Maybe (GroupFeaturePreference f)
Maybe FullDeleteGroupPreference
fullDelete
  SGroupFeature f
SGFReactions -> Maybe (GroupFeaturePreference f)
Maybe ReactionsGroupPreference
reactions
  SGroupFeature f
SGFVoice -> Maybe (GroupFeaturePreference f)
Maybe VoiceGroupPreference
voice
  SGroupFeature f
SGFFiles -> Maybe (GroupFeaturePreference f)
Maybe FilesGroupPreference
files
  SGroupFeature f
SGFSimplexLinks -> Maybe (GroupFeaturePreference f)
Maybe SimplexLinksGroupPreference
simplexLinks
  SGroupFeature f
SGFReports -> Maybe (GroupFeaturePreference f)
Maybe ReportsGroupPreference
reports
  SGroupFeature f
SGFHistory -> Maybe (GroupFeaturePreference f)
Maybe HistoryGroupPreference
history
  SGroupFeature f
SGFSessions -> Maybe (GroupFeaturePreference f)
Maybe SessionsGroupPreference
sessions

toGroupFeature :: SGroupFeature f -> GroupFeature
toGroupFeature :: forall (f :: GroupFeature). SGroupFeature f -> GroupFeature
toGroupFeature = \case
  SGroupFeature f
SGFTimedMessages -> GroupFeature
GFTimedMessages
  SGroupFeature f
SGFDirectMessages -> GroupFeature
GFDirectMessages
  SGroupFeature f
SGFFullDelete -> GroupFeature
GFFullDelete
  SGroupFeature f
SGFReactions -> GroupFeature
GFReactions
  SGroupFeature f
SGFVoice -> GroupFeature
GFVoice
  SGroupFeature f
SGFFiles -> GroupFeature
GFFiles
  SGroupFeature f
SGFSimplexLinks -> GroupFeature
GFSimplexLinks
  SGroupFeature f
SGFReports -> GroupFeature
GFReports
  SGroupFeature f
SGFHistory -> GroupFeature
GFHistory
  SGroupFeature f
SGFSessions -> GroupFeature
GFSessions

class GroupPreferenceI p where
  getGroupPreference :: SGroupFeature f -> p -> GroupFeaturePreference f

instance GroupPreferenceI GroupPreferences where
  getGroupPreference :: forall (f :: GroupFeature).
SGroupFeature f -> GroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
pt GroupPreferences
prefs = GroupFeaturePreference f
-> Maybe (GroupFeaturePreference f) -> GroupFeaturePreference f
forall a. a -> Maybe a -> a
fromMaybe (SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
pt FullGroupPreferences
defaultGroupPrefs) (SGroupFeature f
-> GroupPreferences -> Maybe (GroupFeaturePreference f)
forall (f :: GroupFeature).
SGroupFeature f
-> GroupPreferences -> Maybe (GroupFeaturePreference f)
groupPrefSel SGroupFeature f
pt GroupPreferences
prefs)

instance GroupPreferenceI (Maybe GroupPreferences) where
  getGroupPreference :: forall (f :: GroupFeature).
SGroupFeature f
-> Maybe GroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
pt Maybe GroupPreferences
prefs = GroupFeaturePreference f
-> Maybe (GroupFeaturePreference f) -> GroupFeaturePreference f
forall a. a -> Maybe a -> a
fromMaybe (SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
pt FullGroupPreferences
defaultGroupPrefs) (SGroupFeature f
-> GroupPreferences -> Maybe (GroupFeaturePreference f)
forall (f :: GroupFeature).
SGroupFeature f
-> GroupPreferences -> Maybe (GroupFeaturePreference f)
groupPrefSel SGroupFeature f
pt (GroupPreferences -> Maybe (GroupFeaturePreference f))
-> Maybe GroupPreferences -> Maybe (GroupFeaturePreference f)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Maybe GroupPreferences
prefs)

instance GroupPreferenceI FullGroupPreferences where
  getGroupPreference :: forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
f FullGroupPreferences {TimedMessagesGroupPreference
timedMessages :: TimedMessagesGroupPreference
timedMessages :: FullGroupPreferences -> TimedMessagesGroupPreference
timedMessages, DirectMessagesGroupPreference
directMessages :: DirectMessagesGroupPreference
directMessages :: FullGroupPreferences -> DirectMessagesGroupPreference
directMessages, FullDeleteGroupPreference
fullDelete :: FullDeleteGroupPreference
fullDelete :: FullGroupPreferences -> FullDeleteGroupPreference
fullDelete, ReactionsGroupPreference
reactions :: ReactionsGroupPreference
reactions :: FullGroupPreferences -> ReactionsGroupPreference
reactions, VoiceGroupPreference
voice :: VoiceGroupPreference
voice :: FullGroupPreferences -> VoiceGroupPreference
voice, FilesGroupPreference
files :: FilesGroupPreference
files :: FullGroupPreferences -> FilesGroupPreference
files, SimplexLinksGroupPreference
simplexLinks :: SimplexLinksGroupPreference
simplexLinks :: FullGroupPreferences -> SimplexLinksGroupPreference
simplexLinks, ReportsGroupPreference
reports :: ReportsGroupPreference
reports :: FullGroupPreferences -> ReportsGroupPreference
reports, HistoryGroupPreference
history :: HistoryGroupPreference
history :: FullGroupPreferences -> HistoryGroupPreference
history, SessionsGroupPreference
sessions :: SessionsGroupPreference
sessions :: FullGroupPreferences -> SessionsGroupPreference
sessions} = case SGroupFeature f
f of
    SGroupFeature f
SGFTimedMessages -> GroupFeaturePreference f
TimedMessagesGroupPreference
timedMessages
    SGroupFeature f
SGFDirectMessages -> GroupFeaturePreference f
DirectMessagesGroupPreference
directMessages
    SGroupFeature f
SGFFullDelete -> GroupFeaturePreference f
FullDeleteGroupPreference
fullDelete
    SGroupFeature f
SGFReactions -> GroupFeaturePreference f
ReactionsGroupPreference
reactions
    SGroupFeature f
SGFVoice -> GroupFeaturePreference f
VoiceGroupPreference
voice
    SGroupFeature f
SGFFiles -> GroupFeaturePreference f
FilesGroupPreference
files
    SGroupFeature f
SGFSimplexLinks -> GroupFeaturePreference f
SimplexLinksGroupPreference
simplexLinks
    SGroupFeature f
SGFReports -> GroupFeaturePreference f
ReportsGroupPreference
reports
    SGroupFeature f
SGFHistory -> GroupFeaturePreference f
HistoryGroupPreference
history
    SGroupFeature f
SGFSessions -> GroupFeaturePreference f
SessionsGroupPreference
sessions
  {-# INLINE getGroupPreference #-}

-- collection of optional group preferences
data GroupPreferences = GroupPreferences
  { GroupPreferences -> Maybe TimedMessagesGroupPreference
timedMessages :: Maybe TimedMessagesGroupPreference,
    GroupPreferences -> Maybe DirectMessagesGroupPreference
directMessages :: Maybe DirectMessagesGroupPreference,
    GroupPreferences -> Maybe FullDeleteGroupPreference
fullDelete :: Maybe FullDeleteGroupPreference,
    GroupPreferences -> Maybe ReactionsGroupPreference
reactions :: Maybe ReactionsGroupPreference,
    GroupPreferences -> Maybe VoiceGroupPreference
voice :: Maybe VoiceGroupPreference,
    GroupPreferences -> Maybe FilesGroupPreference
files :: Maybe FilesGroupPreference,
    GroupPreferences -> Maybe SimplexLinksGroupPreference
simplexLinks :: Maybe SimplexLinksGroupPreference,
    GroupPreferences -> Maybe ReportsGroupPreference
reports :: Maybe ReportsGroupPreference,
    GroupPreferences -> Maybe HistoryGroupPreference
history :: Maybe HistoryGroupPreference,
    GroupPreferences -> Maybe SessionsGroupPreference
sessions :: Maybe SessionsGroupPreference,
    GroupPreferences -> Maybe [ChatBotCommand]
commands :: Maybe [ChatBotCommand]
  }
  deriving (GroupPreferences -> GroupPreferences -> Bool
(GroupPreferences -> GroupPreferences -> Bool)
-> (GroupPreferences -> GroupPreferences -> Bool)
-> Eq GroupPreferences
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupPreferences -> GroupPreferences -> Bool
== :: GroupPreferences -> GroupPreferences -> Bool
$c/= :: GroupPreferences -> GroupPreferences -> Bool
/= :: GroupPreferences -> GroupPreferences -> Bool
Eq, Int -> GroupPreferences -> ShowS
[GroupPreferences] -> ShowS
GroupPreferences -> String
(Int -> GroupPreferences -> ShowS)
-> (GroupPreferences -> String)
-> ([GroupPreferences] -> ShowS)
-> Show GroupPreferences
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupPreferences -> ShowS
showsPrec :: Int -> GroupPreferences -> ShowS
$cshow :: GroupPreferences -> String
show :: GroupPreferences -> String
$cshowList :: [GroupPreferences] -> ShowS
showList :: [GroupPreferences] -> ShowS
Show)

instance HasCommands GroupPreferences where commands_ :: GroupPreferences -> Maybe [ChatBotCommand]
commands_ GroupPreferences {Maybe [ChatBotCommand]
commands :: GroupPreferences -> Maybe [ChatBotCommand]
commands :: Maybe [ChatBotCommand]
commands} = Maybe [ChatBotCommand]
commands

data ChatBotCommand
  = CBCCommand
      { ChatBotCommand -> Text
keyword :: Text, -- "order"
        ChatBotCommand -> Text
label :: Text, -- Information about order
        ChatBotCommand -> Maybe Text
params :: Maybe Text -- "<order number>", command is sent on selection if params is absent
      }
  | CBCMenu
      { label :: Text, -- Orders
        ChatBotCommand -> [ChatBotCommand]
commands :: [ChatBotCommand]
      }
  deriving (ChatBotCommand -> ChatBotCommand -> Bool
(ChatBotCommand -> ChatBotCommand -> Bool)
-> (ChatBotCommand -> ChatBotCommand -> Bool) -> Eq ChatBotCommand
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChatBotCommand -> ChatBotCommand -> Bool
== :: ChatBotCommand -> ChatBotCommand -> Bool
$c/= :: ChatBotCommand -> ChatBotCommand -> Bool
/= :: ChatBotCommand -> ChatBotCommand -> Bool
Eq, Int -> ChatBotCommand -> ShowS
[ChatBotCommand] -> ShowS
ChatBotCommand -> String
(Int -> ChatBotCommand -> ShowS)
-> (ChatBotCommand -> String)
-> ([ChatBotCommand] -> ShowS)
-> Show ChatBotCommand
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChatBotCommand -> ShowS
showsPrec :: Int -> ChatBotCommand -> ShowS
$cshow :: ChatBotCommand -> String
show :: ChatBotCommand -> String
$cshowList :: [ChatBotCommand] -> ShowS
showList :: [ChatBotCommand] -> ShowS
Show)

setGroupPreference :: forall f. GroupFeatureNoRoleI f => SGroupFeature f -> GroupFeatureEnabled -> Maybe GroupPreferences -> GroupPreferences
setGroupPreference :: forall (f :: GroupFeature).
GroupFeatureNoRoleI f =>
SGroupFeature f
-> GroupFeatureEnabled
-> Maybe GroupPreferences
-> GroupPreferences
setGroupPreference SGroupFeature f
f GroupFeatureEnabled
enable Maybe GroupPreferences
prefs_ = SGroupFeature f
-> GroupFeaturePreference f
-> FullGroupPreferences
-> GroupPreferences
forall (f :: GroupFeature).
SGroupFeature f
-> GroupFeaturePreference f
-> FullGroupPreferences
-> GroupPreferences
setGroupPreference_ SGroupFeature f
f GroupFeaturePreference f
pref FullGroupPreferences
prefs
  where
    prefs :: FullGroupPreferences
prefs = Maybe GroupPreferences -> FullGroupPreferences
mergeGroupPreferences Maybe GroupPreferences
prefs_
    pref :: GroupFeaturePreference f
    pref :: GroupFeaturePreference f
pref = forall {k} (x :: k) r a. HasField x r a => r -> a -> r
forall (x :: Symbol) r a. HasField x r a => r -> a -> r
setField @"enable" (SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
f FullGroupPreferences
prefs) GroupFeatureEnabled
enable

setGroupPreferenceRole :: forall f. GroupFeatureRoleI f => SGroupFeature f -> GroupFeatureEnabled -> Maybe GroupMemberRole -> Maybe GroupPreferences -> GroupPreferences
setGroupPreferenceRole :: forall (f :: GroupFeature).
GroupFeatureRoleI f =>
SGroupFeature f
-> GroupFeatureEnabled
-> Maybe GroupMemberRole
-> Maybe GroupPreferences
-> GroupPreferences
setGroupPreferenceRole SGroupFeature f
f GroupFeatureEnabled
enable Maybe GroupMemberRole
role Maybe GroupPreferences
prefs_ = SGroupFeature f
-> GroupFeaturePreference f
-> FullGroupPreferences
-> GroupPreferences
forall (f :: GroupFeature).
SGroupFeature f
-> GroupFeaturePreference f
-> FullGroupPreferences
-> GroupPreferences
setGroupPreference_ SGroupFeature f
f GroupFeaturePreference f
pref FullGroupPreferences
prefs
  where
    prefs :: FullGroupPreferences
prefs = Maybe GroupPreferences -> FullGroupPreferences
mergeGroupPreferences Maybe GroupPreferences
prefs_
    pref :: GroupFeaturePreference f
    pref :: GroupFeaturePreference f
pref = forall {k} (x :: k) r a. HasField x r a => r -> a -> r
forall (x :: Symbol) r a. HasField x r a => r -> a -> r
setField @"role" (forall {k} (x :: k) r a. HasField x r a => r -> a -> r
forall (x :: Symbol) r a. HasField x r a => r -> a -> r
setField @"enable" (SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
f FullGroupPreferences
prefs) GroupFeatureEnabled
enable) Maybe GroupMemberRole
role

setGroupPreference' :: SGroupFeature f -> GroupFeaturePreference f -> Maybe GroupPreferences -> GroupPreferences
setGroupPreference' :: forall (f :: GroupFeature).
SGroupFeature f
-> GroupFeaturePreference f
-> Maybe GroupPreferences
-> GroupPreferences
setGroupPreference' SGroupFeature f
f GroupFeaturePreference f
pref Maybe GroupPreferences
prefs_ = SGroupFeature f
-> GroupFeaturePreference f
-> FullGroupPreferences
-> GroupPreferences
forall (f :: GroupFeature).
SGroupFeature f
-> GroupFeaturePreference f
-> FullGroupPreferences
-> GroupPreferences
setGroupPreference_ SGroupFeature f
f GroupFeaturePreference f
pref FullGroupPreferences
prefs
  where
    prefs :: FullGroupPreferences
prefs = Maybe GroupPreferences -> FullGroupPreferences
mergeGroupPreferences Maybe GroupPreferences
prefs_

setGroupPreference_ :: SGroupFeature f -> GroupFeaturePreference f -> FullGroupPreferences -> GroupPreferences
setGroupPreference_ :: forall (f :: GroupFeature).
SGroupFeature f
-> GroupFeaturePreference f
-> FullGroupPreferences
-> GroupPreferences
setGroupPreference_ SGroupFeature f
f GroupFeaturePreference f
pref FullGroupPreferences
prefs =
  FullGroupPreferences -> GroupPreferences
toGroupPreferences (FullGroupPreferences -> GroupPreferences)
-> FullGroupPreferences -> GroupPreferences
forall a b. (a -> b) -> a -> b
$ case SGroupFeature f
f of
    SGroupFeature f
SGFTimedMessages -> FullGroupPreferences
prefs {timedMessages = pref}
    SGroupFeature f
SGFDirectMessages -> FullGroupPreferences
prefs {directMessages = pref}
    SGroupFeature f
SGFFullDelete -> FullGroupPreferences
prefs {fullDelete = pref}
    SGroupFeature f
SGFReactions -> FullGroupPreferences
prefs {reactions = pref}
    SGroupFeature f
SGFVoice -> FullGroupPreferences
prefs {voice = pref}
    SGroupFeature f
SGFFiles -> FullGroupPreferences
prefs {files = pref}
    SGroupFeature f
SGFSimplexLinks -> FullGroupPreferences
prefs {simplexLinks = pref}
    SGroupFeature f
SGFReports -> FullGroupPreferences
prefs {reports = pref}
    SGroupFeature f
SGFHistory -> FullGroupPreferences
prefs {history = pref}
    SGroupFeature f
SGFSessions -> FullGroupPreferences
prefs {sessions = pref}

setGroupTimedMessagesPreference :: TimedMessagesGroupPreference -> Maybe GroupPreferences -> GroupPreferences
setGroupTimedMessagesPreference :: TimedMessagesGroupPreference
-> Maybe GroupPreferences -> GroupPreferences
setGroupTimedMessagesPreference TimedMessagesGroupPreference
pref Maybe GroupPreferences
prefs_ =
  FullGroupPreferences -> GroupPreferences
toGroupPreferences (FullGroupPreferences -> GroupPreferences)
-> FullGroupPreferences -> GroupPreferences
forall a b. (a -> b) -> a -> b
$ FullGroupPreferences
prefs {timedMessages = pref}
  where
    prefs :: FullGroupPreferences
prefs = Maybe GroupPreferences -> FullGroupPreferences
mergeGroupPreferences Maybe GroupPreferences
prefs_

-- full collection of chat preferences defined in the app - it is used to ensure we include all preferences and to simplify processing
-- if some of the preferences are not defined in Preferences, defaults from defaultChatPrefs are used here.
data FullPreferences = FullPreferences
  { FullPreferences -> TimedMessagesPreference
timedMessages :: TimedMessagesPreference,
    FullPreferences -> FullDeletePreference
fullDelete :: FullDeletePreference,
    FullPreferences -> ReactionsPreference
reactions :: ReactionsPreference,
    FullPreferences -> VoicePreference
voice :: VoicePreference,
    FullPreferences -> FilesPreference
files :: FilesPreference,
    FullPreferences -> CallsPreference
calls :: CallsPreference,
    FullPreferences -> SessionsPreference
sessions :: SessionsPreference,
    FullPreferences -> ListDef ChatBotCommand
commands :: ListDef ChatBotCommand
  }
  deriving (FullPreferences -> FullPreferences -> Bool
(FullPreferences -> FullPreferences -> Bool)
-> (FullPreferences -> FullPreferences -> Bool)
-> Eq FullPreferences
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FullPreferences -> FullPreferences -> Bool
== :: FullPreferences -> FullPreferences -> Bool
$c/= :: FullPreferences -> FullPreferences -> Bool
/= :: FullPreferences -> FullPreferences -> Bool
Eq, Int -> FullPreferences -> ShowS
[FullPreferences] -> ShowS
FullPreferences -> String
(Int -> FullPreferences -> ShowS)
-> (FullPreferences -> String)
-> ([FullPreferences] -> ShowS)
-> Show FullPreferences
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FullPreferences -> ShowS
showsPrec :: Int -> FullPreferences -> ShowS
$cshow :: FullPreferences -> String
show :: FullPreferences -> String
$cshowList :: [FullPreferences] -> ShowS
showList :: [FullPreferences] -> ShowS
Show)

newtype ListDef a = ListDef [a]
  deriving (ListDef a -> ListDef a -> Bool
(ListDef a -> ListDef a -> Bool)
-> (ListDef a -> ListDef a -> Bool) -> Eq (ListDef a)
forall a. Eq a => ListDef a -> ListDef a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ListDef a -> ListDef a -> Bool
== :: ListDef a -> ListDef a -> Bool
$c/= :: forall a. Eq a => ListDef a -> ListDef a -> Bool
/= :: ListDef a -> ListDef a -> Bool
Eq, Int -> ListDef a -> ShowS
[ListDef a] -> ShowS
ListDef a -> String
(Int -> ListDef a -> ShowS)
-> (ListDef a -> String)
-> ([ListDef a] -> ShowS)
-> Show (ListDef a)
forall a. Show a => Int -> ListDef a -> ShowS
forall a. Show a => [ListDef a] -> ShowS
forall a. Show a => ListDef a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ListDef a -> ShowS
showsPrec :: Int -> ListDef a -> ShowS
$cshow :: forall a. Show a => ListDef a -> String
show :: ListDef a -> String
$cshowList :: forall a. Show a => [ListDef a] -> ShowS
showList :: [ListDef a] -> ShowS
Show)
  deriving newtype ([ListDef a] -> Encoding
[ListDef a] -> Value
ListDef a -> Bool
ListDef a -> Encoding
ListDef a -> Value
(ListDef a -> Value)
-> (ListDef a -> Encoding)
-> ([ListDef a] -> Value)
-> ([ListDef a] -> Encoding)
-> (ListDef a -> Bool)
-> ToJSON (ListDef a)
forall a. ToJSON a => [ListDef a] -> Encoding
forall a. ToJSON a => [ListDef a] -> Value
forall a. ToJSON a => ListDef a -> Bool
forall a. ToJSON a => ListDef a -> Encoding
forall a. ToJSON a => ListDef a -> Value
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: forall a. ToJSON a => ListDef a -> Value
toJSON :: ListDef a -> Value
$ctoEncoding :: forall a. ToJSON a => ListDef a -> Encoding
toEncoding :: ListDef a -> Encoding
$ctoJSONList :: forall a. ToJSON a => [ListDef a] -> Value
toJSONList :: [ListDef a] -> Value
$ctoEncodingList :: forall a. ToJSON a => [ListDef a] -> Encoding
toEncodingList :: [ListDef a] -> Encoding
$comitField :: forall a. ToJSON a => ListDef a -> Bool
omitField :: ListDef a -> Bool
ToJSON)

instance FromJSON a => FromJSON (ListDef a) where
  parseJSON :: Value -> Parser (ListDef a)
parseJSON Value
v = [a] -> ListDef a
forall a. [a] -> ListDef a
ListDef ([a] -> ListDef a) -> Parser [a] -> Parser (ListDef a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser [a]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
  omittedField :: Maybe (ListDef a)
omittedField = ListDef a -> Maybe (ListDef a)
forall a. a -> Maybe a
Just ([a] -> ListDef a
forall a. [a] -> ListDef a
ListDef [])

-- full collection of group preferences defined in the app - it is used to ensure we include all preferences and to simplify processing
-- if some of the preferences are not defined in GroupPreferences, defaults from defaultGroupPrefs are used here.
data FullGroupPreferences = FullGroupPreferences
  { FullGroupPreferences -> TimedMessagesGroupPreference
timedMessages :: TimedMessagesGroupPreference,
    FullGroupPreferences -> DirectMessagesGroupPreference
directMessages :: DirectMessagesGroupPreference,
    FullGroupPreferences -> FullDeleteGroupPreference
fullDelete :: FullDeleteGroupPreference,
    FullGroupPreferences -> ReactionsGroupPreference
reactions :: ReactionsGroupPreference,
    FullGroupPreferences -> VoiceGroupPreference
voice :: VoiceGroupPreference,
    FullGroupPreferences -> FilesGroupPreference
files :: FilesGroupPreference,
    FullGroupPreferences -> SimplexLinksGroupPreference
simplexLinks :: SimplexLinksGroupPreference,
    FullGroupPreferences -> ReportsGroupPreference
reports :: ReportsGroupPreference,
    FullGroupPreferences -> HistoryGroupPreference
history :: HistoryGroupPreference,
    FullGroupPreferences -> SessionsGroupPreference
sessions :: SessionsGroupPreference,
    FullGroupPreferences -> ListDef ChatBotCommand
commands :: ListDef ChatBotCommand
  }
  deriving (FullGroupPreferences -> FullGroupPreferences -> Bool
(FullGroupPreferences -> FullGroupPreferences -> Bool)
-> (FullGroupPreferences -> FullGroupPreferences -> Bool)
-> Eq FullGroupPreferences
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FullGroupPreferences -> FullGroupPreferences -> Bool
== :: FullGroupPreferences -> FullGroupPreferences -> Bool
$c/= :: FullGroupPreferences -> FullGroupPreferences -> Bool
/= :: FullGroupPreferences -> FullGroupPreferences -> Bool
Eq, Int -> FullGroupPreferences -> ShowS
[FullGroupPreferences] -> ShowS
FullGroupPreferences -> String
(Int -> FullGroupPreferences -> ShowS)
-> (FullGroupPreferences -> String)
-> ([FullGroupPreferences] -> ShowS)
-> Show FullGroupPreferences
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FullGroupPreferences -> ShowS
showsPrec :: Int -> FullGroupPreferences -> ShowS
$cshow :: FullGroupPreferences -> String
show :: FullGroupPreferences -> String
$cshowList :: [FullGroupPreferences] -> ShowS
showList :: [FullGroupPreferences] -> ShowS
Show)

-- merged preferences of user for a given contact - they differentiate between specific preferences for the contact and global user preferences
data ContactUserPreferences = ContactUserPreferences
  { ContactUserPreferences
-> ContactUserPreference TimedMessagesPreference
timedMessages :: ContactUserPreference TimedMessagesPreference,
    ContactUserPreferences
-> ContactUserPreference FullDeletePreference
fullDelete :: ContactUserPreference FullDeletePreference,
    ContactUserPreferences -> ContactUserPreference ReactionsPreference
reactions :: ContactUserPreference ReactionsPreference,
    ContactUserPreferences -> ContactUserPreference VoicePreference
voice :: ContactUserPreference VoicePreference,
    ContactUserPreferences -> ContactUserPreference FilesPreference
files :: ContactUserPreference FilesPreference,
    ContactUserPreferences -> ContactUserPreference CallsPreference
calls :: ContactUserPreference CallsPreference,
    ContactUserPreferences -> ContactUserPreference SessionsPreference
sessions :: ContactUserPreference SessionsPreference,
    ContactUserPreferences -> Maybe [ChatBotCommand]
commands :: Maybe [ChatBotCommand]
  }
  deriving (ContactUserPreferences -> ContactUserPreferences -> Bool
(ContactUserPreferences -> ContactUserPreferences -> Bool)
-> (ContactUserPreferences -> ContactUserPreferences -> Bool)
-> Eq ContactUserPreferences
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContactUserPreferences -> ContactUserPreferences -> Bool
== :: ContactUserPreferences -> ContactUserPreferences -> Bool
$c/= :: ContactUserPreferences -> ContactUserPreferences -> Bool
/= :: ContactUserPreferences -> ContactUserPreferences -> Bool
Eq, Int -> ContactUserPreferences -> ShowS
[ContactUserPreferences] -> ShowS
ContactUserPreferences -> String
(Int -> ContactUserPreferences -> ShowS)
-> (ContactUserPreferences -> String)
-> ([ContactUserPreferences] -> ShowS)
-> Show ContactUserPreferences
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContactUserPreferences -> ShowS
showsPrec :: Int -> ContactUserPreferences -> ShowS
$cshow :: ContactUserPreferences -> String
show :: ContactUserPreferences -> String
$cshowList :: [ContactUserPreferences] -> ShowS
showList :: [ContactUserPreferences] -> ShowS
Show)

data ContactUserPreference p = ContactUserPreference
  { forall p. ContactUserPreference p -> PrefEnabled
enabled :: PrefEnabled,
    forall p. ContactUserPreference p -> ContactUserPref p
userPreference :: ContactUserPref p,
    forall p. ContactUserPreference p -> p
contactPreference :: p
  }
  deriving (ContactUserPreference p -> ContactUserPreference p -> Bool
(ContactUserPreference p -> ContactUserPreference p -> Bool)
-> (ContactUserPreference p -> ContactUserPreference p -> Bool)
-> Eq (ContactUserPreference p)
forall p.
Eq p =>
ContactUserPreference p -> ContactUserPreference p -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall p.
Eq p =>
ContactUserPreference p -> ContactUserPreference p -> Bool
== :: ContactUserPreference p -> ContactUserPreference p -> Bool
$c/= :: forall p.
Eq p =>
ContactUserPreference p -> ContactUserPreference p -> Bool
/= :: ContactUserPreference p -> ContactUserPreference p -> Bool
Eq, Int -> ContactUserPreference p -> ShowS
[ContactUserPreference p] -> ShowS
ContactUserPreference p -> String
(Int -> ContactUserPreference p -> ShowS)
-> (ContactUserPreference p -> String)
-> ([ContactUserPreference p] -> ShowS)
-> Show (ContactUserPreference p)
forall p. Show p => Int -> ContactUserPreference p -> ShowS
forall p. Show p => [ContactUserPreference p] -> ShowS
forall p. Show p => ContactUserPreference p -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall p. Show p => Int -> ContactUserPreference p -> ShowS
showsPrec :: Int -> ContactUserPreference p -> ShowS
$cshow :: forall p. Show p => ContactUserPreference p -> String
show :: ContactUserPreference p -> String
$cshowList :: forall p. Show p => [ContactUserPreference p] -> ShowS
showList :: [ContactUserPreference p] -> ShowS
Show)

data ContactUserPref p = CUPContact {forall p. ContactUserPref p -> p
preference :: p} | CUPUser {preference :: p}
  deriving (ContactUserPref p -> ContactUserPref p -> Bool
(ContactUserPref p -> ContactUserPref p -> Bool)
-> (ContactUserPref p -> ContactUserPref p -> Bool)
-> Eq (ContactUserPref p)
forall p. Eq p => ContactUserPref p -> ContactUserPref p -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall p. Eq p => ContactUserPref p -> ContactUserPref p -> Bool
== :: ContactUserPref p -> ContactUserPref p -> Bool
$c/= :: forall p. Eq p => ContactUserPref p -> ContactUserPref p -> Bool
/= :: ContactUserPref p -> ContactUserPref p -> Bool
Eq, Int -> ContactUserPref p -> ShowS
[ContactUserPref p] -> ShowS
ContactUserPref p -> String
(Int -> ContactUserPref p -> ShowS)
-> (ContactUserPref p -> String)
-> ([ContactUserPref p] -> ShowS)
-> Show (ContactUserPref p)
forall p. Show p => Int -> ContactUserPref p -> ShowS
forall p. Show p => [ContactUserPref p] -> ShowS
forall p. Show p => ContactUserPref p -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall p. Show p => Int -> ContactUserPref p -> ShowS
showsPrec :: Int -> ContactUserPref p -> ShowS
$cshow :: forall p. Show p => ContactUserPref p -> String
show :: ContactUserPref p -> String
$cshowList :: forall p. Show p => [ContactUserPref p] -> ShowS
showList :: [ContactUserPref p] -> ShowS
Show)

toChatPrefs :: FullPreferences -> Preferences
toChatPrefs :: FullPreferences -> Preferences
toChatPrefs FullPreferences {TimedMessagesPreference
timedMessages :: FullPreferences -> TimedMessagesPreference
timedMessages :: TimedMessagesPreference
timedMessages, FullDeletePreference
fullDelete :: FullPreferences -> FullDeletePreference
fullDelete :: FullDeletePreference
fullDelete, ReactionsPreference
reactions :: FullPreferences -> ReactionsPreference
reactions :: ReactionsPreference
reactions, VoicePreference
voice :: FullPreferences -> VoicePreference
voice :: VoicePreference
voice, FilesPreference
files :: FullPreferences -> FilesPreference
files :: FilesPreference
files, CallsPreference
calls :: FullPreferences -> CallsPreference
calls :: CallsPreference
calls, SessionsPreference
sessions :: FullPreferences -> SessionsPreference
sessions :: SessionsPreference
sessions, commands :: FullPreferences -> ListDef ChatBotCommand
commands = ListDef [ChatBotCommand]
cmds} =
  Preferences
    { timedMessages :: Maybe TimedMessagesPreference
timedMessages = TimedMessagesPreference -> Maybe TimedMessagesPreference
forall a. a -> Maybe a
Just TimedMessagesPreference
timedMessages,
      fullDelete :: Maybe FullDeletePreference
fullDelete = FullDeletePreference -> Maybe FullDeletePreference
forall a. a -> Maybe a
Just FullDeletePreference
fullDelete,
      reactions :: Maybe ReactionsPreference
reactions = ReactionsPreference -> Maybe ReactionsPreference
forall a. a -> Maybe a
Just ReactionsPreference
reactions,
      voice :: Maybe VoicePreference
voice = VoicePreference -> Maybe VoicePreference
forall a. a -> Maybe a
Just VoicePreference
voice,
      files :: Maybe FilesPreference
files = FilesPreference -> Maybe FilesPreference
forall a. a -> Maybe a
Just FilesPreference
files,
      calls :: Maybe CallsPreference
calls = CallsPreference -> Maybe CallsPreference
forall a. a -> Maybe a
Just CallsPreference
calls,
      sessions :: Maybe SessionsPreference
sessions = SessionsPreference -> Maybe SessionsPreference
forall a. a -> Maybe a
Just SessionsPreference
sessions,
      commands :: Maybe [ChatBotCommand]
commands = [ChatBotCommand] -> Maybe [ChatBotCommand]
forall a. a -> Maybe a
Just [ChatBotCommand]
cmds
    }

defaultChatPrefs :: FullPreferences
defaultChatPrefs :: FullPreferences
defaultChatPrefs =
  FullPreferences
    { timedMessages :: TimedMessagesPreference
timedMessages = TimedMessagesPreference {allow :: FeatureAllowed
allow = FeatureAllowed
FAYes, ttl :: Maybe Int
ttl = Maybe Int
forall a. Maybe a
Nothing},
      fullDelete :: FullDeletePreference
fullDelete = FullDeletePreference {allow :: FeatureAllowed
allow = FeatureAllowed
FANo},
      reactions :: ReactionsPreference
reactions = ReactionsPreference {allow :: FeatureAllowed
allow = FeatureAllowed
FAYes},
      voice :: VoicePreference
voice = VoicePreference {allow :: FeatureAllowed
allow = FeatureAllowed
FAYes},
      files :: FilesPreference
files = FilesPreference {allow :: FeatureAllowed
allow = FeatureAllowed
FAAlways},
      calls :: CallsPreference
calls = CallsPreference {allow :: FeatureAllowed
allow = FeatureAllowed
FAYes},
      sessions :: SessionsPreference
sessions = SessionsPreference {allow :: FeatureAllowed
allow = FeatureAllowed
FANo},
      commands :: ListDef ChatBotCommand
commands = [ChatBotCommand] -> ListDef ChatBotCommand
forall a. [a] -> ListDef a
ListDef []
    }

emptyChatPrefs :: Preferences
emptyChatPrefs :: Preferences
emptyChatPrefs = Maybe TimedMessagesPreference
-> Maybe FullDeletePreference
-> Maybe ReactionsPreference
-> Maybe VoicePreference
-> Maybe FilesPreference
-> Maybe CallsPreference
-> Maybe SessionsPreference
-> Maybe [ChatBotCommand]
-> Preferences
Preferences Maybe TimedMessagesPreference
forall a. Maybe a
Nothing Maybe FullDeletePreference
forall a. Maybe a
Nothing Maybe ReactionsPreference
forall a. Maybe a
Nothing Maybe VoicePreference
forall a. Maybe a
Nothing Maybe FilesPreference
forall a. Maybe a
Nothing Maybe CallsPreference
forall a. Maybe a
Nothing Maybe SessionsPreference
forall a. Maybe a
Nothing Maybe [ChatBotCommand]
forall a. Maybe a
Nothing

defaultGroupPrefs :: FullGroupPreferences
defaultGroupPrefs :: FullGroupPreferences
defaultGroupPrefs =
  FullGroupPreferences
    { timedMessages :: TimedMessagesGroupPreference
timedMessages = TimedMessagesGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOff, ttl :: Maybe Int
ttl = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
86400},
      directMessages :: DirectMessagesGroupPreference
directMessages = DirectMessagesGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOff, role :: Maybe GroupMemberRole
role = Maybe GroupMemberRole
forall a. Maybe a
Nothing},
      fullDelete :: FullDeleteGroupPreference
fullDelete = FullDeleteGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOff, role :: Maybe GroupMemberRole
role = Maybe GroupMemberRole
forall a. Maybe a
Nothing},
      reactions :: ReactionsGroupPreference
reactions = ReactionsGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOn},
      voice :: VoiceGroupPreference
voice = VoiceGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOn, role :: Maybe GroupMemberRole
role = Maybe GroupMemberRole
forall a. Maybe a
Nothing},
      files :: FilesGroupPreference
files = FilesGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOn, role :: Maybe GroupMemberRole
role = Maybe GroupMemberRole
forall a. Maybe a
Nothing},
      simplexLinks :: SimplexLinksGroupPreference
simplexLinks = SimplexLinksGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOn, role :: Maybe GroupMemberRole
role = Maybe GroupMemberRole
forall a. Maybe a
Nothing},
      reports :: ReportsGroupPreference
reports = ReportsGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOn},
      history :: HistoryGroupPreference
history = HistoryGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOff},
      sessions :: SessionsGroupPreference
sessions = SessionsGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOff, role :: Maybe GroupMemberRole
role = Maybe GroupMemberRole
forall a. Maybe a
Nothing},
      commands :: ListDef ChatBotCommand
commands = [ChatBotCommand] -> ListDef ChatBotCommand
forall a. [a] -> ListDef a
ListDef []
    }

emptyGroupPrefs :: GroupPreferences
emptyGroupPrefs :: GroupPreferences
emptyGroupPrefs = Maybe TimedMessagesGroupPreference
-> Maybe DirectMessagesGroupPreference
-> Maybe FullDeleteGroupPreference
-> Maybe ReactionsGroupPreference
-> Maybe VoiceGroupPreference
-> Maybe FilesGroupPreference
-> Maybe SimplexLinksGroupPreference
-> Maybe ReportsGroupPreference
-> Maybe HistoryGroupPreference
-> Maybe SessionsGroupPreference
-> Maybe [ChatBotCommand]
-> GroupPreferences
GroupPreferences Maybe TimedMessagesGroupPreference
forall a. Maybe a
Nothing Maybe DirectMessagesGroupPreference
forall a. Maybe a
Nothing Maybe FullDeleteGroupPreference
forall a. Maybe a
Nothing Maybe ReactionsGroupPreference
forall a. Maybe a
Nothing Maybe VoiceGroupPreference
forall a. Maybe a
Nothing Maybe FilesGroupPreference
forall a. Maybe a
Nothing Maybe SimplexLinksGroupPreference
forall a. Maybe a
Nothing Maybe ReportsGroupPreference
forall a. Maybe a
Nothing Maybe HistoryGroupPreference
forall a. Maybe a
Nothing Maybe SessionsGroupPreference
forall a. Maybe a
Nothing Maybe [ChatBotCommand]
forall a. Maybe a
Nothing

businessGroupPrefs :: Preferences -> GroupPreferences
businessGroupPrefs :: Preferences -> GroupPreferences
businessGroupPrefs Preferences {Maybe TimedMessagesPreference
timedMessages :: Preferences -> Maybe TimedMessagesPreference
timedMessages :: Maybe TimedMessagesPreference
timedMessages, Maybe FullDeletePreference
fullDelete :: Preferences -> Maybe FullDeletePreference
fullDelete :: Maybe FullDeletePreference
fullDelete, Maybe ReactionsPreference
reactions :: Preferences -> Maybe ReactionsPreference
reactions :: Maybe ReactionsPreference
reactions, Maybe VoicePreference
voice :: Preferences -> Maybe VoicePreference
voice :: Maybe VoicePreference
voice, Maybe FilesPreference
files :: Preferences -> Maybe FilesPreference
files :: Maybe FilesPreference
files, Maybe SessionsPreference
sessions :: Preferences -> Maybe SessionsPreference
sessions :: Maybe SessionsPreference
sessions, Maybe [ChatBotCommand]
commands :: Preferences -> Maybe [ChatBotCommand]
commands :: Maybe [ChatBotCommand]
commands} =
  GroupPreferences
defaultBusinessGroupPrefs
    { timedMessages = Just TimedMessagesGroupPreference {enable = maybe FEOff enableFeature timedMessages, ttl = maybe Nothing prefParam timedMessages},
      fullDelete = Just FullDeleteGroupPreference {enable = maybe FEOff enableFeature fullDelete, role = Nothing},
      reactions = Just ReactionsGroupPreference {enable = maybe FEOn enableFeature reactions},
      voice = Just VoiceGroupPreference {enable = maybe FEOff enableFeature voice, role = Nothing},
      files = Just FilesGroupPreference {enable = maybe FEOn enableFeature files, role = Nothing},
      sessions = Just SessionsGroupPreference {enable = maybe FEOff enableFeature sessions, role = Nothing},
      commands
    }
  where
    enableFeature :: FeatureI f => FeaturePreference f -> GroupFeatureEnabled
    enableFeature :: forall (f :: ChatFeature).
FeatureI f =>
FeaturePreference f -> GroupFeatureEnabled
enableFeature FeaturePreference f
p = case forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"allow" FeaturePreference f
p of
      FeatureAllowed
FANo -> GroupFeatureEnabled
FEOff
      FeatureAllowed
_ -> GroupFeatureEnabled
FEOn

defaultBusinessGroupPrefs :: GroupPreferences
defaultBusinessGroupPrefs :: GroupPreferences
defaultBusinessGroupPrefs =
  GroupPreferences
    { timedMessages :: Maybe TimedMessagesGroupPreference
timedMessages = TimedMessagesGroupPreference -> Maybe TimedMessagesGroupPreference
forall a. a -> Maybe a
Just (TimedMessagesGroupPreference
 -> Maybe TimedMessagesGroupPreference)
-> TimedMessagesGroupPreference
-> Maybe TimedMessagesGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled -> Maybe Int -> TimedMessagesGroupPreference
TimedMessagesGroupPreference GroupFeatureEnabled
FEOff Maybe Int
forall a. Maybe a
Nothing,
      directMessages :: Maybe DirectMessagesGroupPreference
directMessages = DirectMessagesGroupPreference
-> Maybe DirectMessagesGroupPreference
forall a. a -> Maybe a
Just (DirectMessagesGroupPreference
 -> Maybe DirectMessagesGroupPreference)
-> DirectMessagesGroupPreference
-> Maybe DirectMessagesGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled
-> Maybe GroupMemberRole -> DirectMessagesGroupPreference
DirectMessagesGroupPreference GroupFeatureEnabled
FEOff Maybe GroupMemberRole
forall a. Maybe a
Nothing,
      fullDelete :: Maybe FullDeleteGroupPreference
fullDelete = FullDeleteGroupPreference -> Maybe FullDeleteGroupPreference
forall a. a -> Maybe a
Just (FullDeleteGroupPreference -> Maybe FullDeleteGroupPreference)
-> FullDeleteGroupPreference -> Maybe FullDeleteGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled
-> Maybe GroupMemberRole -> FullDeleteGroupPreference
FullDeleteGroupPreference GroupFeatureEnabled
FEOn (GroupMemberRole -> Maybe GroupMemberRole
forall a. a -> Maybe a
Just GroupMemberRole
GRModerator),
      reactions :: Maybe ReactionsGroupPreference
reactions = ReactionsGroupPreference -> Maybe ReactionsGroupPreference
forall a. a -> Maybe a
Just (ReactionsGroupPreference -> Maybe ReactionsGroupPreference)
-> ReactionsGroupPreference -> Maybe ReactionsGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled -> ReactionsGroupPreference
ReactionsGroupPreference GroupFeatureEnabled
FEOn,
      voice :: Maybe VoiceGroupPreference
voice = VoiceGroupPreference -> Maybe VoiceGroupPreference
forall a. a -> Maybe a
Just (VoiceGroupPreference -> Maybe VoiceGroupPreference)
-> VoiceGroupPreference -> Maybe VoiceGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled
-> Maybe GroupMemberRole -> VoiceGroupPreference
VoiceGroupPreference GroupFeatureEnabled
FEOff Maybe GroupMemberRole
forall a. Maybe a
Nothing,
      files :: Maybe FilesGroupPreference
files = FilesGroupPreference -> Maybe FilesGroupPreference
forall a. a -> Maybe a
Just (FilesGroupPreference -> Maybe FilesGroupPreference)
-> FilesGroupPreference -> Maybe FilesGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled
-> Maybe GroupMemberRole -> FilesGroupPreference
FilesGroupPreference GroupFeatureEnabled
FEOn Maybe GroupMemberRole
forall a. Maybe a
Nothing,
      simplexLinks :: Maybe SimplexLinksGroupPreference
simplexLinks = SimplexLinksGroupPreference -> Maybe SimplexLinksGroupPreference
forall a. a -> Maybe a
Just (SimplexLinksGroupPreference -> Maybe SimplexLinksGroupPreference)
-> SimplexLinksGroupPreference -> Maybe SimplexLinksGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled
-> Maybe GroupMemberRole -> SimplexLinksGroupPreference
SimplexLinksGroupPreference GroupFeatureEnabled
FEOn Maybe GroupMemberRole
forall a. Maybe a
Nothing,
      reports :: Maybe ReportsGroupPreference
reports = ReportsGroupPreference -> Maybe ReportsGroupPreference
forall a. a -> Maybe a
Just (ReportsGroupPreference -> Maybe ReportsGroupPreference)
-> ReportsGroupPreference -> Maybe ReportsGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled -> ReportsGroupPreference
ReportsGroupPreference GroupFeatureEnabled
FEOff,
      history :: Maybe HistoryGroupPreference
history = HistoryGroupPreference -> Maybe HistoryGroupPreference
forall a. a -> Maybe a
Just (HistoryGroupPreference -> Maybe HistoryGroupPreference)
-> HistoryGroupPreference -> Maybe HistoryGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled -> HistoryGroupPreference
HistoryGroupPreference GroupFeatureEnabled
FEOn,
      sessions :: Maybe SessionsGroupPreference
sessions = SessionsGroupPreference -> Maybe SessionsGroupPreference
forall a. a -> Maybe a
Just (SessionsGroupPreference -> Maybe SessionsGroupPreference)
-> SessionsGroupPreference -> Maybe SessionsGroupPreference
forall a b. (a -> b) -> a -> b
$ GroupFeatureEnabled
-> Maybe GroupMemberRole -> SessionsGroupPreference
SessionsGroupPreference GroupFeatureEnabled
FEOn Maybe GroupMemberRole
forall a. Maybe a
Nothing,
      commands :: Maybe [ChatBotCommand]
commands = Maybe [ChatBotCommand]
forall a. Maybe a
Nothing
    }

data TimedMessagesPreference = TimedMessagesPreference
  { TimedMessagesPreference -> FeatureAllowed
allow :: FeatureAllowed,
    TimedMessagesPreference -> Maybe Int
ttl :: Maybe Int
  }
  deriving (TimedMessagesPreference -> TimedMessagesPreference -> Bool
(TimedMessagesPreference -> TimedMessagesPreference -> Bool)
-> (TimedMessagesPreference -> TimedMessagesPreference -> Bool)
-> Eq TimedMessagesPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TimedMessagesPreference -> TimedMessagesPreference -> Bool
== :: TimedMessagesPreference -> TimedMessagesPreference -> Bool
$c/= :: TimedMessagesPreference -> TimedMessagesPreference -> Bool
/= :: TimedMessagesPreference -> TimedMessagesPreference -> Bool
Eq, Int -> TimedMessagesPreference -> ShowS
[TimedMessagesPreference] -> ShowS
TimedMessagesPreference -> String
(Int -> TimedMessagesPreference -> ShowS)
-> (TimedMessagesPreference -> String)
-> ([TimedMessagesPreference] -> ShowS)
-> Show TimedMessagesPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TimedMessagesPreference -> ShowS
showsPrec :: Int -> TimedMessagesPreference -> ShowS
$cshow :: TimedMessagesPreference -> String
show :: TimedMessagesPreference -> String
$cshowList :: [TimedMessagesPreference] -> ShowS
showList :: [TimedMessagesPreference] -> ShowS
Show)

data FullDeletePreference = FullDeletePreference {FullDeletePreference -> FeatureAllowed
allow :: FeatureAllowed}
  deriving (FullDeletePreference -> FullDeletePreference -> Bool
(FullDeletePreference -> FullDeletePreference -> Bool)
-> (FullDeletePreference -> FullDeletePreference -> Bool)
-> Eq FullDeletePreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FullDeletePreference -> FullDeletePreference -> Bool
== :: FullDeletePreference -> FullDeletePreference -> Bool
$c/= :: FullDeletePreference -> FullDeletePreference -> Bool
/= :: FullDeletePreference -> FullDeletePreference -> Bool
Eq, Int -> FullDeletePreference -> ShowS
[FullDeletePreference] -> ShowS
FullDeletePreference -> String
(Int -> FullDeletePreference -> ShowS)
-> (FullDeletePreference -> String)
-> ([FullDeletePreference] -> ShowS)
-> Show FullDeletePreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FullDeletePreference -> ShowS
showsPrec :: Int -> FullDeletePreference -> ShowS
$cshow :: FullDeletePreference -> String
show :: FullDeletePreference -> String
$cshowList :: [FullDeletePreference] -> ShowS
showList :: [FullDeletePreference] -> ShowS
Show)

data ReactionsPreference = ReactionsPreference {ReactionsPreference -> FeatureAllowed
allow :: FeatureAllowed}
  deriving (ReactionsPreference -> ReactionsPreference -> Bool
(ReactionsPreference -> ReactionsPreference -> Bool)
-> (ReactionsPreference -> ReactionsPreference -> Bool)
-> Eq ReactionsPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReactionsPreference -> ReactionsPreference -> Bool
== :: ReactionsPreference -> ReactionsPreference -> Bool
$c/= :: ReactionsPreference -> ReactionsPreference -> Bool
/= :: ReactionsPreference -> ReactionsPreference -> Bool
Eq, Int -> ReactionsPreference -> ShowS
[ReactionsPreference] -> ShowS
ReactionsPreference -> String
(Int -> ReactionsPreference -> ShowS)
-> (ReactionsPreference -> String)
-> ([ReactionsPreference] -> ShowS)
-> Show ReactionsPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReactionsPreference -> ShowS
showsPrec :: Int -> ReactionsPreference -> ShowS
$cshow :: ReactionsPreference -> String
show :: ReactionsPreference -> String
$cshowList :: [ReactionsPreference] -> ShowS
showList :: [ReactionsPreference] -> ShowS
Show)

data VoicePreference = VoicePreference {VoicePreference -> FeatureAllowed
allow :: FeatureAllowed}
  deriving (VoicePreference -> VoicePreference -> Bool
(VoicePreference -> VoicePreference -> Bool)
-> (VoicePreference -> VoicePreference -> Bool)
-> Eq VoicePreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VoicePreference -> VoicePreference -> Bool
== :: VoicePreference -> VoicePreference -> Bool
$c/= :: VoicePreference -> VoicePreference -> Bool
/= :: VoicePreference -> VoicePreference -> Bool
Eq, Int -> VoicePreference -> ShowS
[VoicePreference] -> ShowS
VoicePreference -> String
(Int -> VoicePreference -> ShowS)
-> (VoicePreference -> String)
-> ([VoicePreference] -> ShowS)
-> Show VoicePreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VoicePreference -> ShowS
showsPrec :: Int -> VoicePreference -> ShowS
$cshow :: VoicePreference -> String
show :: VoicePreference -> String
$cshowList :: [VoicePreference] -> ShowS
showList :: [VoicePreference] -> ShowS
Show)

data FilesPreference = FilesPreference {FilesPreference -> FeatureAllowed
allow :: FeatureAllowed}
  deriving (FilesPreference -> FilesPreference -> Bool
(FilesPreference -> FilesPreference -> Bool)
-> (FilesPreference -> FilesPreference -> Bool)
-> Eq FilesPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FilesPreference -> FilesPreference -> Bool
== :: FilesPreference -> FilesPreference -> Bool
$c/= :: FilesPreference -> FilesPreference -> Bool
/= :: FilesPreference -> FilesPreference -> Bool
Eq, Int -> FilesPreference -> ShowS
[FilesPreference] -> ShowS
FilesPreference -> String
(Int -> FilesPreference -> ShowS)
-> (FilesPreference -> String)
-> ([FilesPreference] -> ShowS)
-> Show FilesPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FilesPreference -> ShowS
showsPrec :: Int -> FilesPreference -> ShowS
$cshow :: FilesPreference -> String
show :: FilesPreference -> String
$cshowList :: [FilesPreference] -> ShowS
showList :: [FilesPreference] -> ShowS
Show)

data CallsPreference = CallsPreference {CallsPreference -> FeatureAllowed
allow :: FeatureAllowed}
  deriving (CallsPreference -> CallsPreference -> Bool
(CallsPreference -> CallsPreference -> Bool)
-> (CallsPreference -> CallsPreference -> Bool)
-> Eq CallsPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CallsPreference -> CallsPreference -> Bool
== :: CallsPreference -> CallsPreference -> Bool
$c/= :: CallsPreference -> CallsPreference -> Bool
/= :: CallsPreference -> CallsPreference -> Bool
Eq, Int -> CallsPreference -> ShowS
[CallsPreference] -> ShowS
CallsPreference -> String
(Int -> CallsPreference -> ShowS)
-> (CallsPreference -> String)
-> ([CallsPreference] -> ShowS)
-> Show CallsPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CallsPreference -> ShowS
showsPrec :: Int -> CallsPreference -> ShowS
$cshow :: CallsPreference -> String
show :: CallsPreference -> String
$cshowList :: [CallsPreference] -> ShowS
showList :: [CallsPreference] -> ShowS
Show)

data SessionsPreference = SessionsPreference {SessionsPreference -> FeatureAllowed
allow :: FeatureAllowed}
  deriving (SessionsPreference -> SessionsPreference -> Bool
(SessionsPreference -> SessionsPreference -> Bool)
-> (SessionsPreference -> SessionsPreference -> Bool)
-> Eq SessionsPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SessionsPreference -> SessionsPreference -> Bool
== :: SessionsPreference -> SessionsPreference -> Bool
$c/= :: SessionsPreference -> SessionsPreference -> Bool
/= :: SessionsPreference -> SessionsPreference -> Bool
Eq, Int -> SessionsPreference -> ShowS
[SessionsPreference] -> ShowS
SessionsPreference -> String
(Int -> SessionsPreference -> ShowS)
-> (SessionsPreference -> String)
-> ([SessionsPreference] -> ShowS)
-> Show SessionsPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SessionsPreference -> ShowS
showsPrec :: Int -> SessionsPreference -> ShowS
$cshow :: SessionsPreference -> String
show :: SessionsPreference -> String
$cshowList :: [SessionsPreference] -> ShowS
showList :: [SessionsPreference] -> ShowS
Show)

class (Eq (FeaturePreference f), HasField "allow" (FeaturePreference f) FeatureAllowed) => FeatureI f where
  type FeaturePreference (f :: ChatFeature) = p | p -> f
  sFeature :: SChatFeature f
  prefParam :: FeaturePreference f -> Maybe Int

instance HasField "allow" TimedMessagesPreference FeatureAllowed where
  hasField :: TimedMessagesPreference
-> (FeatureAllowed -> TimedMessagesPreference, FeatureAllowed)
hasField p :: TimedMessagesPreference
p@TimedMessagesPreference {FeatureAllowed
allow :: TimedMessagesPreference -> FeatureAllowed
allow :: FeatureAllowed
allow} = (\FeatureAllowed
a -> TimedMessagesPreference
p {allow = a}, FeatureAllowed
allow)

instance HasField "allow" FullDeletePreference FeatureAllowed where
  hasField :: FullDeletePreference
-> (FeatureAllowed -> FullDeletePreference, FeatureAllowed)
hasField p :: FullDeletePreference
p@FullDeletePreference {FeatureAllowed
allow :: FullDeletePreference -> FeatureAllowed
allow :: FeatureAllowed
allow} = (\FeatureAllowed
a -> FullDeletePreference
p {allow = a}, FeatureAllowed
allow)

instance HasField "allow" ReactionsPreference FeatureAllowed where
  hasField :: ReactionsPreference
-> (FeatureAllowed -> ReactionsPreference, FeatureAllowed)
hasField p :: ReactionsPreference
p@ReactionsPreference {FeatureAllowed
allow :: ReactionsPreference -> FeatureAllowed
allow :: FeatureAllowed
allow} = (\FeatureAllowed
a -> ReactionsPreference
p {allow = a}, FeatureAllowed
allow)

instance HasField "allow" VoicePreference FeatureAllowed where
  hasField :: VoicePreference
-> (FeatureAllowed -> VoicePreference, FeatureAllowed)
hasField p :: VoicePreference
p@VoicePreference {FeatureAllowed
allow :: VoicePreference -> FeatureAllowed
allow :: FeatureAllowed
allow} = (\FeatureAllowed
a -> VoicePreference
p {allow = a}, FeatureAllowed
allow)

instance HasField "allow" FilesPreference FeatureAllowed where
  hasField :: FilesPreference
-> (FeatureAllowed -> FilesPreference, FeatureAllowed)
hasField p :: FilesPreference
p@FilesPreference {FeatureAllowed
allow :: FilesPreference -> FeatureAllowed
allow :: FeatureAllowed
allow} = (\FeatureAllowed
a -> FilesPreference
p {allow = a}, FeatureAllowed
allow)

instance HasField "allow" CallsPreference FeatureAllowed where
  hasField :: CallsPreference
-> (FeatureAllowed -> CallsPreference, FeatureAllowed)
hasField p :: CallsPreference
p@CallsPreference {FeatureAllowed
allow :: CallsPreference -> FeatureAllowed
allow :: FeatureAllowed
allow} = (\FeatureAllowed
a -> CallsPreference
p {allow = a}, FeatureAllowed
allow)

instance HasField "allow" SessionsPreference FeatureAllowed where
  hasField :: SessionsPreference
-> (FeatureAllowed -> SessionsPreference, FeatureAllowed)
hasField p :: SessionsPreference
p@SessionsPreference {FeatureAllowed
allow :: SessionsPreference -> FeatureAllowed
allow :: FeatureAllowed
allow} = (\FeatureAllowed
a -> SessionsPreference
p {allow = a}, FeatureAllowed
allow)

instance FeatureI 'CFTimedMessages where
  type FeaturePreference 'CFTimedMessages = TimedMessagesPreference
  sFeature :: SChatFeature 'CFTimedMessages
sFeature = SChatFeature 'CFTimedMessages
SCFTimedMessages
  prefParam :: FeaturePreference 'CFTimedMessages -> Maybe Int
prefParam TimedMessagesPreference {Maybe Int
ttl :: TimedMessagesPreference -> Maybe Int
ttl :: Maybe Int
ttl} = Maybe Int
ttl

instance FeatureI 'CFFullDelete where
  type FeaturePreference 'CFFullDelete = FullDeletePreference
  sFeature :: SChatFeature 'CFFullDelete
sFeature = SChatFeature 'CFFullDelete
SCFFullDelete
  prefParam :: FeaturePreference 'CFFullDelete -> Maybe Int
prefParam FeaturePreference 'CFFullDelete
_ = Maybe Int
forall a. Maybe a
Nothing

instance FeatureI 'CFReactions where
  type FeaturePreference 'CFReactions = ReactionsPreference
  sFeature :: SChatFeature 'CFReactions
sFeature = SChatFeature 'CFReactions
SCFReactions
  prefParam :: FeaturePreference 'CFReactions -> Maybe Int
prefParam FeaturePreference 'CFReactions
_ = Maybe Int
forall a. Maybe a
Nothing

instance FeatureI 'CFVoice where
  type FeaturePreference 'CFVoice = VoicePreference
  sFeature :: SChatFeature 'CFVoice
sFeature = SChatFeature 'CFVoice
SCFVoice
  prefParam :: FeaturePreference 'CFVoice -> Maybe Int
prefParam FeaturePreference 'CFVoice
_ = Maybe Int
forall a. Maybe a
Nothing

instance FeatureI 'CFFiles where
  type FeaturePreference 'CFFiles = FilesPreference
  sFeature :: SChatFeature 'CFFiles
sFeature = SChatFeature 'CFFiles
SCFFiles
  prefParam :: FeaturePreference 'CFFiles -> Maybe Int
prefParam FeaturePreference 'CFFiles
_ = Maybe Int
forall a. Maybe a
Nothing

instance FeatureI 'CFCalls where
  type FeaturePreference 'CFCalls = CallsPreference
  sFeature :: SChatFeature 'CFCalls
sFeature = SChatFeature 'CFCalls
SCFCalls
  prefParam :: FeaturePreference 'CFCalls -> Maybe Int
prefParam FeaturePreference 'CFCalls
_ = Maybe Int
forall a. Maybe a
Nothing

instance FeatureI 'CFSessions where
  type FeaturePreference 'CFSessions = SessionsPreference
  sFeature :: SChatFeature 'CFSessions
sFeature = SChatFeature 'CFSessions
SCFSessions
  prefParam :: FeaturePreference 'CFSessions -> Maybe Int
prefParam FeaturePreference 'CFSessions
_ = Maybe Int
forall a. Maybe a
Nothing

data GroupPreference = GroupPreference
  {GroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled}
  deriving (GroupPreference -> GroupPreference -> Bool
(GroupPreference -> GroupPreference -> Bool)
-> (GroupPreference -> GroupPreference -> Bool)
-> Eq GroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupPreference -> GroupPreference -> Bool
== :: GroupPreference -> GroupPreference -> Bool
$c/= :: GroupPreference -> GroupPreference -> Bool
/= :: GroupPreference -> GroupPreference -> Bool
Eq, Int -> GroupPreference -> ShowS
[GroupPreference] -> ShowS
GroupPreference -> String
(Int -> GroupPreference -> ShowS)
-> (GroupPreference -> String)
-> ([GroupPreference] -> ShowS)
-> Show GroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupPreference -> ShowS
showsPrec :: Int -> GroupPreference -> ShowS
$cshow :: GroupPreference -> String
show :: GroupPreference -> String
$cshowList :: [GroupPreference] -> ShowS
showList :: [GroupPreference] -> ShowS
Show)

data TimedMessagesGroupPreference = TimedMessagesGroupPreference
  { TimedMessagesGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled,
    TimedMessagesGroupPreference -> Maybe Int
ttl :: Maybe Int
  }
  deriving (TimedMessagesGroupPreference
-> TimedMessagesGroupPreference -> Bool
(TimedMessagesGroupPreference
 -> TimedMessagesGroupPreference -> Bool)
-> (TimedMessagesGroupPreference
    -> TimedMessagesGroupPreference -> Bool)
-> Eq TimedMessagesGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TimedMessagesGroupPreference
-> TimedMessagesGroupPreference -> Bool
== :: TimedMessagesGroupPreference
-> TimedMessagesGroupPreference -> Bool
$c/= :: TimedMessagesGroupPreference
-> TimedMessagesGroupPreference -> Bool
/= :: TimedMessagesGroupPreference
-> TimedMessagesGroupPreference -> Bool
Eq, Int -> TimedMessagesGroupPreference -> ShowS
[TimedMessagesGroupPreference] -> ShowS
TimedMessagesGroupPreference -> String
(Int -> TimedMessagesGroupPreference -> ShowS)
-> (TimedMessagesGroupPreference -> String)
-> ([TimedMessagesGroupPreference] -> ShowS)
-> Show TimedMessagesGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TimedMessagesGroupPreference -> ShowS
showsPrec :: Int -> TimedMessagesGroupPreference -> ShowS
$cshow :: TimedMessagesGroupPreference -> String
show :: TimedMessagesGroupPreference -> String
$cshowList :: [TimedMessagesGroupPreference] -> ShowS
showList :: [TimedMessagesGroupPreference] -> ShowS
Show)

data DirectMessagesGroupPreference = DirectMessagesGroupPreference
  {DirectMessagesGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled, DirectMessagesGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole}
  deriving (DirectMessagesGroupPreference
-> DirectMessagesGroupPreference -> Bool
(DirectMessagesGroupPreference
 -> DirectMessagesGroupPreference -> Bool)
-> (DirectMessagesGroupPreference
    -> DirectMessagesGroupPreference -> Bool)
-> Eq DirectMessagesGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DirectMessagesGroupPreference
-> DirectMessagesGroupPreference -> Bool
== :: DirectMessagesGroupPreference
-> DirectMessagesGroupPreference -> Bool
$c/= :: DirectMessagesGroupPreference
-> DirectMessagesGroupPreference -> Bool
/= :: DirectMessagesGroupPreference
-> DirectMessagesGroupPreference -> Bool
Eq, Int -> DirectMessagesGroupPreference -> ShowS
[DirectMessagesGroupPreference] -> ShowS
DirectMessagesGroupPreference -> String
(Int -> DirectMessagesGroupPreference -> ShowS)
-> (DirectMessagesGroupPreference -> String)
-> ([DirectMessagesGroupPreference] -> ShowS)
-> Show DirectMessagesGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DirectMessagesGroupPreference -> ShowS
showsPrec :: Int -> DirectMessagesGroupPreference -> ShowS
$cshow :: DirectMessagesGroupPreference -> String
show :: DirectMessagesGroupPreference -> String
$cshowList :: [DirectMessagesGroupPreference] -> ShowS
showList :: [DirectMessagesGroupPreference] -> ShowS
Show)

data FullDeleteGroupPreference = FullDeleteGroupPreference
  {FullDeleteGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled, FullDeleteGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole}
  deriving (FullDeleteGroupPreference -> FullDeleteGroupPreference -> Bool
(FullDeleteGroupPreference -> FullDeleteGroupPreference -> Bool)
-> (FullDeleteGroupPreference -> FullDeleteGroupPreference -> Bool)
-> Eq FullDeleteGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FullDeleteGroupPreference -> FullDeleteGroupPreference -> Bool
== :: FullDeleteGroupPreference -> FullDeleteGroupPreference -> Bool
$c/= :: FullDeleteGroupPreference -> FullDeleteGroupPreference -> Bool
/= :: FullDeleteGroupPreference -> FullDeleteGroupPreference -> Bool
Eq, Int -> FullDeleteGroupPreference -> ShowS
[FullDeleteGroupPreference] -> ShowS
FullDeleteGroupPreference -> String
(Int -> FullDeleteGroupPreference -> ShowS)
-> (FullDeleteGroupPreference -> String)
-> ([FullDeleteGroupPreference] -> ShowS)
-> Show FullDeleteGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FullDeleteGroupPreference -> ShowS
showsPrec :: Int -> FullDeleteGroupPreference -> ShowS
$cshow :: FullDeleteGroupPreference -> String
show :: FullDeleteGroupPreference -> String
$cshowList :: [FullDeleteGroupPreference] -> ShowS
showList :: [FullDeleteGroupPreference] -> ShowS
Show)

data ReactionsGroupPreference = ReactionsGroupPreference
  {ReactionsGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled}
  deriving (ReactionsGroupPreference -> ReactionsGroupPreference -> Bool
(ReactionsGroupPreference -> ReactionsGroupPreference -> Bool)
-> (ReactionsGroupPreference -> ReactionsGroupPreference -> Bool)
-> Eq ReactionsGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReactionsGroupPreference -> ReactionsGroupPreference -> Bool
== :: ReactionsGroupPreference -> ReactionsGroupPreference -> Bool
$c/= :: ReactionsGroupPreference -> ReactionsGroupPreference -> Bool
/= :: ReactionsGroupPreference -> ReactionsGroupPreference -> Bool
Eq, Int -> ReactionsGroupPreference -> ShowS
[ReactionsGroupPreference] -> ShowS
ReactionsGroupPreference -> String
(Int -> ReactionsGroupPreference -> ShowS)
-> (ReactionsGroupPreference -> String)
-> ([ReactionsGroupPreference] -> ShowS)
-> Show ReactionsGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReactionsGroupPreference -> ShowS
showsPrec :: Int -> ReactionsGroupPreference -> ShowS
$cshow :: ReactionsGroupPreference -> String
show :: ReactionsGroupPreference -> String
$cshowList :: [ReactionsGroupPreference] -> ShowS
showList :: [ReactionsGroupPreference] -> ShowS
Show)

data VoiceGroupPreference = VoiceGroupPreference
  {VoiceGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled, VoiceGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole}
  deriving (VoiceGroupPreference -> VoiceGroupPreference -> Bool
(VoiceGroupPreference -> VoiceGroupPreference -> Bool)
-> (VoiceGroupPreference -> VoiceGroupPreference -> Bool)
-> Eq VoiceGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VoiceGroupPreference -> VoiceGroupPreference -> Bool
== :: VoiceGroupPreference -> VoiceGroupPreference -> Bool
$c/= :: VoiceGroupPreference -> VoiceGroupPreference -> Bool
/= :: VoiceGroupPreference -> VoiceGroupPreference -> Bool
Eq, Int -> VoiceGroupPreference -> ShowS
[VoiceGroupPreference] -> ShowS
VoiceGroupPreference -> String
(Int -> VoiceGroupPreference -> ShowS)
-> (VoiceGroupPreference -> String)
-> ([VoiceGroupPreference] -> ShowS)
-> Show VoiceGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VoiceGroupPreference -> ShowS
showsPrec :: Int -> VoiceGroupPreference -> ShowS
$cshow :: VoiceGroupPreference -> String
show :: VoiceGroupPreference -> String
$cshowList :: [VoiceGroupPreference] -> ShowS
showList :: [VoiceGroupPreference] -> ShowS
Show)

data FilesGroupPreference = FilesGroupPreference
  {FilesGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled, FilesGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole}
  deriving (FilesGroupPreference -> FilesGroupPreference -> Bool
(FilesGroupPreference -> FilesGroupPreference -> Bool)
-> (FilesGroupPreference -> FilesGroupPreference -> Bool)
-> Eq FilesGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FilesGroupPreference -> FilesGroupPreference -> Bool
== :: FilesGroupPreference -> FilesGroupPreference -> Bool
$c/= :: FilesGroupPreference -> FilesGroupPreference -> Bool
/= :: FilesGroupPreference -> FilesGroupPreference -> Bool
Eq, Int -> FilesGroupPreference -> ShowS
[FilesGroupPreference] -> ShowS
FilesGroupPreference -> String
(Int -> FilesGroupPreference -> ShowS)
-> (FilesGroupPreference -> String)
-> ([FilesGroupPreference] -> ShowS)
-> Show FilesGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FilesGroupPreference -> ShowS
showsPrec :: Int -> FilesGroupPreference -> ShowS
$cshow :: FilesGroupPreference -> String
show :: FilesGroupPreference -> String
$cshowList :: [FilesGroupPreference] -> ShowS
showList :: [FilesGroupPreference] -> ShowS
Show)

data SimplexLinksGroupPreference = SimplexLinksGroupPreference
  {SimplexLinksGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled, SimplexLinksGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole}
  deriving (SimplexLinksGroupPreference -> SimplexLinksGroupPreference -> Bool
(SimplexLinksGroupPreference
 -> SimplexLinksGroupPreference -> Bool)
-> (SimplexLinksGroupPreference
    -> SimplexLinksGroupPreference -> Bool)
-> Eq SimplexLinksGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimplexLinksGroupPreference -> SimplexLinksGroupPreference -> Bool
== :: SimplexLinksGroupPreference -> SimplexLinksGroupPreference -> Bool
$c/= :: SimplexLinksGroupPreference -> SimplexLinksGroupPreference -> Bool
/= :: SimplexLinksGroupPreference -> SimplexLinksGroupPreference -> Bool
Eq, Int -> SimplexLinksGroupPreference -> ShowS
[SimplexLinksGroupPreference] -> ShowS
SimplexLinksGroupPreference -> String
(Int -> SimplexLinksGroupPreference -> ShowS)
-> (SimplexLinksGroupPreference -> String)
-> ([SimplexLinksGroupPreference] -> ShowS)
-> Show SimplexLinksGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SimplexLinksGroupPreference -> ShowS
showsPrec :: Int -> SimplexLinksGroupPreference -> ShowS
$cshow :: SimplexLinksGroupPreference -> String
show :: SimplexLinksGroupPreference -> String
$cshowList :: [SimplexLinksGroupPreference] -> ShowS
showList :: [SimplexLinksGroupPreference] -> ShowS
Show)

data ReportsGroupPreference = ReportsGroupPreference
  {ReportsGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled}
  deriving (ReportsGroupPreference -> ReportsGroupPreference -> Bool
(ReportsGroupPreference -> ReportsGroupPreference -> Bool)
-> (ReportsGroupPreference -> ReportsGroupPreference -> Bool)
-> Eq ReportsGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReportsGroupPreference -> ReportsGroupPreference -> Bool
== :: ReportsGroupPreference -> ReportsGroupPreference -> Bool
$c/= :: ReportsGroupPreference -> ReportsGroupPreference -> Bool
/= :: ReportsGroupPreference -> ReportsGroupPreference -> Bool
Eq, Int -> ReportsGroupPreference -> ShowS
[ReportsGroupPreference] -> ShowS
ReportsGroupPreference -> String
(Int -> ReportsGroupPreference -> ShowS)
-> (ReportsGroupPreference -> String)
-> ([ReportsGroupPreference] -> ShowS)
-> Show ReportsGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReportsGroupPreference -> ShowS
showsPrec :: Int -> ReportsGroupPreference -> ShowS
$cshow :: ReportsGroupPreference -> String
show :: ReportsGroupPreference -> String
$cshowList :: [ReportsGroupPreference] -> ShowS
showList :: [ReportsGroupPreference] -> ShowS
Show)

data HistoryGroupPreference = HistoryGroupPreference
  {HistoryGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled}
  deriving (HistoryGroupPreference -> HistoryGroupPreference -> Bool
(HistoryGroupPreference -> HistoryGroupPreference -> Bool)
-> (HistoryGroupPreference -> HistoryGroupPreference -> Bool)
-> Eq HistoryGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HistoryGroupPreference -> HistoryGroupPreference -> Bool
== :: HistoryGroupPreference -> HistoryGroupPreference -> Bool
$c/= :: HistoryGroupPreference -> HistoryGroupPreference -> Bool
/= :: HistoryGroupPreference -> HistoryGroupPreference -> Bool
Eq, Int -> HistoryGroupPreference -> ShowS
[HistoryGroupPreference] -> ShowS
HistoryGroupPreference -> String
(Int -> HistoryGroupPreference -> ShowS)
-> (HistoryGroupPreference -> String)
-> ([HistoryGroupPreference] -> ShowS)
-> Show HistoryGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HistoryGroupPreference -> ShowS
showsPrec :: Int -> HistoryGroupPreference -> ShowS
$cshow :: HistoryGroupPreference -> String
show :: HistoryGroupPreference -> String
$cshowList :: [HistoryGroupPreference] -> ShowS
showList :: [HistoryGroupPreference] -> ShowS
Show)

data SessionsGroupPreference = SessionsGroupPreference
  {SessionsGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled, SessionsGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole}
  deriving (SessionsGroupPreference -> SessionsGroupPreference -> Bool
(SessionsGroupPreference -> SessionsGroupPreference -> Bool)
-> (SessionsGroupPreference -> SessionsGroupPreference -> Bool)
-> Eq SessionsGroupPreference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SessionsGroupPreference -> SessionsGroupPreference -> Bool
== :: SessionsGroupPreference -> SessionsGroupPreference -> Bool
$c/= :: SessionsGroupPreference -> SessionsGroupPreference -> Bool
/= :: SessionsGroupPreference -> SessionsGroupPreference -> Bool
Eq, Int -> SessionsGroupPreference -> ShowS
[SessionsGroupPreference] -> ShowS
SessionsGroupPreference -> String
(Int -> SessionsGroupPreference -> ShowS)
-> (SessionsGroupPreference -> String)
-> ([SessionsGroupPreference] -> ShowS)
-> Show SessionsGroupPreference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SessionsGroupPreference -> ShowS
showsPrec :: Int -> SessionsGroupPreference -> ShowS
$cshow :: SessionsGroupPreference -> String
show :: SessionsGroupPreference -> String
$cshowList :: [SessionsGroupPreference] -> ShowS
showList :: [SessionsGroupPreference] -> ShowS
Show)

class (Eq (GroupFeaturePreference f), HasField "enable" (GroupFeaturePreference f) GroupFeatureEnabled) => GroupFeatureI f where
  type GroupFeaturePreference (f :: GroupFeature) = p | p -> f
  sGroupFeature :: SGroupFeature f
  groupPrefParam :: GroupFeaturePreference f -> Maybe Int
  groupPrefRole :: GroupFeaturePreference f -> Maybe GroupMemberRole

class GroupFeatureI f => GroupFeatureNoRoleI f

class (GroupFeatureI f, HasField "role" (GroupFeaturePreference f) (Maybe GroupMemberRole)) => GroupFeatureRoleI f

instance HasField "enable" GroupPreference GroupFeatureEnabled where
  hasField :: GroupPreference
-> (GroupFeatureEnabled -> GroupPreference, GroupFeatureEnabled)
hasField p :: GroupPreference
p@GroupPreference {GroupFeatureEnabled
enable :: GroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> GroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" TimedMessagesGroupPreference GroupFeatureEnabled where
  hasField :: TimedMessagesGroupPreference
-> (GroupFeatureEnabled -> TimedMessagesGroupPreference,
    GroupFeatureEnabled)
hasField p :: TimedMessagesGroupPreference
p@TimedMessagesGroupPreference {GroupFeatureEnabled
enable :: TimedMessagesGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> TimedMessagesGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" DirectMessagesGroupPreference GroupFeatureEnabled where
  hasField :: DirectMessagesGroupPreference
-> (GroupFeatureEnabled -> DirectMessagesGroupPreference,
    GroupFeatureEnabled)
hasField p :: DirectMessagesGroupPreference
p@DirectMessagesGroupPreference {GroupFeatureEnabled
enable :: DirectMessagesGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> DirectMessagesGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" ReactionsGroupPreference GroupFeatureEnabled where
  hasField :: ReactionsGroupPreference
-> (GroupFeatureEnabled -> ReactionsGroupPreference,
    GroupFeatureEnabled)
hasField p :: ReactionsGroupPreference
p@ReactionsGroupPreference {GroupFeatureEnabled
enable :: ReactionsGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> ReactionsGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" FullDeleteGroupPreference GroupFeatureEnabled where
  hasField :: FullDeleteGroupPreference
-> (GroupFeatureEnabled -> FullDeleteGroupPreference,
    GroupFeatureEnabled)
hasField p :: FullDeleteGroupPreference
p@FullDeleteGroupPreference {GroupFeatureEnabled
enable :: FullDeleteGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> FullDeleteGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" VoiceGroupPreference GroupFeatureEnabled where
  hasField :: VoiceGroupPreference
-> (GroupFeatureEnabled -> VoiceGroupPreference,
    GroupFeatureEnabled)
hasField p :: VoiceGroupPreference
p@VoiceGroupPreference {GroupFeatureEnabled
enable :: VoiceGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> VoiceGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" FilesGroupPreference GroupFeatureEnabled where
  hasField :: FilesGroupPreference
-> (GroupFeatureEnabled -> FilesGroupPreference,
    GroupFeatureEnabled)
hasField p :: FilesGroupPreference
p@FilesGroupPreference {GroupFeatureEnabled
enable :: FilesGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> FilesGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" SimplexLinksGroupPreference GroupFeatureEnabled where
  hasField :: SimplexLinksGroupPreference
-> (GroupFeatureEnabled -> SimplexLinksGroupPreference,
    GroupFeatureEnabled)
hasField p :: SimplexLinksGroupPreference
p@SimplexLinksGroupPreference {GroupFeatureEnabled
enable :: SimplexLinksGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> SimplexLinksGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" ReportsGroupPreference GroupFeatureEnabled where
  hasField :: ReportsGroupPreference
-> (GroupFeatureEnabled -> ReportsGroupPreference,
    GroupFeatureEnabled)
hasField p :: ReportsGroupPreference
p@ReportsGroupPreference {GroupFeatureEnabled
enable :: ReportsGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> ReportsGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" HistoryGroupPreference GroupFeatureEnabled where
  hasField :: HistoryGroupPreference
-> (GroupFeatureEnabled -> HistoryGroupPreference,
    GroupFeatureEnabled)
hasField p :: HistoryGroupPreference
p@HistoryGroupPreference {GroupFeatureEnabled
enable :: HistoryGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> HistoryGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance HasField "enable" SessionsGroupPreference GroupFeatureEnabled where
  hasField :: SessionsGroupPreference
-> (GroupFeatureEnabled -> SessionsGroupPreference,
    GroupFeatureEnabled)
hasField p :: SessionsGroupPreference
p@SessionsGroupPreference {GroupFeatureEnabled
enable :: SessionsGroupPreference -> GroupFeatureEnabled
enable :: GroupFeatureEnabled
enable} = (\GroupFeatureEnabled
e -> SessionsGroupPreference
p {enable = e}, GroupFeatureEnabled
enable)

instance GroupFeatureI 'GFTimedMessages where
  type GroupFeaturePreference 'GFTimedMessages = TimedMessagesGroupPreference
  sGroupFeature :: SGroupFeature 'GFTimedMessages
sGroupFeature = SGroupFeature 'GFTimedMessages
SGFTimedMessages
  groupPrefParam :: GroupFeaturePreference 'GFTimedMessages -> Maybe Int
groupPrefParam TimedMessagesGroupPreference {Maybe Int
ttl :: TimedMessagesGroupPreference -> Maybe Int
ttl :: Maybe Int
ttl} = Maybe Int
ttl
  groupPrefRole :: GroupFeaturePreference 'GFTimedMessages -> Maybe GroupMemberRole
groupPrefRole GroupFeaturePreference 'GFTimedMessages
_ = Maybe GroupMemberRole
forall a. Maybe a
Nothing

instance GroupFeatureI 'GFDirectMessages where
  type GroupFeaturePreference 'GFDirectMessages = DirectMessagesGroupPreference
  sGroupFeature :: SGroupFeature 'GFDirectMessages
sGroupFeature = SGroupFeature 'GFDirectMessages
SGFDirectMessages
  groupPrefParam :: GroupFeaturePreference 'GFDirectMessages -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFDirectMessages
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFDirectMessages -> Maybe GroupMemberRole
groupPrefRole DirectMessagesGroupPreference {Maybe GroupMemberRole
role :: DirectMessagesGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = Maybe GroupMemberRole
role

instance GroupFeatureI 'GFFullDelete where
  type GroupFeaturePreference 'GFFullDelete = FullDeleteGroupPreference
  sGroupFeature :: SGroupFeature 'GFFullDelete
sGroupFeature = SGroupFeature 'GFFullDelete
SGFFullDelete
  groupPrefParam :: GroupFeaturePreference 'GFFullDelete -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFFullDelete
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFFullDelete -> Maybe GroupMemberRole
groupPrefRole FullDeleteGroupPreference {Maybe GroupMemberRole
role :: FullDeleteGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = Maybe GroupMemberRole
role

instance GroupFeatureI 'GFReactions where
  type GroupFeaturePreference 'GFReactions = ReactionsGroupPreference
  sGroupFeature :: SGroupFeature 'GFReactions
sGroupFeature = SGroupFeature 'GFReactions
SGFReactions
  groupPrefParam :: GroupFeaturePreference 'GFReactions -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFReactions
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFReactions -> Maybe GroupMemberRole
groupPrefRole GroupFeaturePreference 'GFReactions
_ = Maybe GroupMemberRole
forall a. Maybe a
Nothing

instance GroupFeatureI 'GFVoice where
  type GroupFeaturePreference 'GFVoice = VoiceGroupPreference
  sGroupFeature :: SGroupFeature 'GFVoice
sGroupFeature = SGroupFeature 'GFVoice
SGFVoice
  groupPrefParam :: GroupFeaturePreference 'GFVoice -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFVoice
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFVoice -> Maybe GroupMemberRole
groupPrefRole VoiceGroupPreference {Maybe GroupMemberRole
role :: VoiceGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = Maybe GroupMemberRole
role

instance GroupFeatureI 'GFFiles where
  type GroupFeaturePreference 'GFFiles = FilesGroupPreference
  sGroupFeature :: SGroupFeature 'GFFiles
sGroupFeature = SGroupFeature 'GFFiles
SGFFiles
  groupPrefParam :: GroupFeaturePreference 'GFFiles -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFFiles
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFFiles -> Maybe GroupMemberRole
groupPrefRole FilesGroupPreference {Maybe GroupMemberRole
role :: FilesGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = Maybe GroupMemberRole
role

instance GroupFeatureI 'GFSimplexLinks where
  type GroupFeaturePreference 'GFSimplexLinks = SimplexLinksGroupPreference
  sGroupFeature :: SGroupFeature 'GFSimplexLinks
sGroupFeature = SGroupFeature 'GFSimplexLinks
SGFSimplexLinks
  groupPrefParam :: GroupFeaturePreference 'GFSimplexLinks -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFSimplexLinks
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFSimplexLinks -> Maybe GroupMemberRole
groupPrefRole SimplexLinksGroupPreference {Maybe GroupMemberRole
role :: SimplexLinksGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = Maybe GroupMemberRole
role

instance GroupFeatureI 'GFReports where
  type GroupFeaturePreference 'GFReports = ReportsGroupPreference
  sGroupFeature :: SGroupFeature 'GFReports
sGroupFeature = SGroupFeature 'GFReports
SGFReports
  groupPrefParam :: GroupFeaturePreference 'GFReports -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFReports
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFReports -> Maybe GroupMemberRole
groupPrefRole GroupFeaturePreference 'GFReports
_ = Maybe GroupMemberRole
forall a. Maybe a
Nothing

instance GroupFeatureI 'GFHistory where
  type GroupFeaturePreference 'GFHistory = HistoryGroupPreference
  sGroupFeature :: SGroupFeature 'GFHistory
sGroupFeature = SGroupFeature 'GFHistory
SGFHistory
  groupPrefParam :: GroupFeaturePreference 'GFHistory -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFHistory
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFHistory -> Maybe GroupMemberRole
groupPrefRole GroupFeaturePreference 'GFHistory
_ = Maybe GroupMemberRole
forall a. Maybe a
Nothing

instance GroupFeatureI 'GFSessions where
  type GroupFeaturePreference 'GFSessions = SessionsGroupPreference
  sGroupFeature :: SGroupFeature 'GFSessions
sGroupFeature = SGroupFeature 'GFSessions
SGFSessions
  groupPrefParam :: GroupFeaturePreference 'GFSessions -> Maybe Int
groupPrefParam GroupFeaturePreference 'GFSessions
_ = Maybe Int
forall a. Maybe a
Nothing
  groupPrefRole :: GroupFeaturePreference 'GFSessions -> Maybe GroupMemberRole
groupPrefRole SessionsGroupPreference {Maybe GroupMemberRole
role :: SessionsGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = Maybe GroupMemberRole
role

instance GroupFeatureNoRoleI 'GFTimedMessages

instance GroupFeatureNoRoleI 'GFFullDelete

instance GroupFeatureNoRoleI 'GFReactions

instance GroupFeatureNoRoleI 'GFReports

instance GroupFeatureNoRoleI 'GFHistory

instance HasField "role" DirectMessagesGroupPreference (Maybe GroupMemberRole) where
  hasField :: DirectMessagesGroupPreference
-> (Maybe GroupMemberRole -> DirectMessagesGroupPreference,
    Maybe GroupMemberRole)
hasField p :: DirectMessagesGroupPreference
p@DirectMessagesGroupPreference {Maybe GroupMemberRole
role :: DirectMessagesGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = (\Maybe GroupMemberRole
r -> DirectMessagesGroupPreference
p {role = r}, Maybe GroupMemberRole
role)

instance HasField "role" FullDeleteGroupPreference (Maybe GroupMemberRole) where
  hasField :: FullDeleteGroupPreference
-> (Maybe GroupMemberRole -> FullDeleteGroupPreference,
    Maybe GroupMemberRole)
hasField p :: FullDeleteGroupPreference
p@FullDeleteGroupPreference {Maybe GroupMemberRole
role :: FullDeleteGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = (\Maybe GroupMemberRole
r -> FullDeleteGroupPreference
p {role = r}, Maybe GroupMemberRole
role)

instance HasField "role" VoiceGroupPreference (Maybe GroupMemberRole) where
  hasField :: VoiceGroupPreference
-> (Maybe GroupMemberRole -> VoiceGroupPreference,
    Maybe GroupMemberRole)
hasField p :: VoiceGroupPreference
p@VoiceGroupPreference {Maybe GroupMemberRole
role :: VoiceGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = (\Maybe GroupMemberRole
r -> VoiceGroupPreference
p {role = r}, Maybe GroupMemberRole
role)

instance HasField "role" FilesGroupPreference (Maybe GroupMemberRole) where
  hasField :: FilesGroupPreference
-> (Maybe GroupMemberRole -> FilesGroupPreference,
    Maybe GroupMemberRole)
hasField p :: FilesGroupPreference
p@FilesGroupPreference {Maybe GroupMemberRole
role :: FilesGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = (\Maybe GroupMemberRole
r -> FilesGroupPreference
p {role = r}, Maybe GroupMemberRole
role)

instance HasField "role" SimplexLinksGroupPreference (Maybe GroupMemberRole) where
  hasField :: SimplexLinksGroupPreference
-> (Maybe GroupMemberRole -> SimplexLinksGroupPreference,
    Maybe GroupMemberRole)
hasField p :: SimplexLinksGroupPreference
p@SimplexLinksGroupPreference {Maybe GroupMemberRole
role :: SimplexLinksGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = (\Maybe GroupMemberRole
r -> SimplexLinksGroupPreference
p {role = r}, Maybe GroupMemberRole
role)

instance HasField "role" SessionsGroupPreference (Maybe GroupMemberRole) where
  hasField :: SessionsGroupPreference
-> (Maybe GroupMemberRole -> SessionsGroupPreference,
    Maybe GroupMemberRole)
hasField p :: SessionsGroupPreference
p@SessionsGroupPreference {Maybe GroupMemberRole
role :: SessionsGroupPreference -> Maybe GroupMemberRole
role :: Maybe GroupMemberRole
role} = (\Maybe GroupMemberRole
r -> SessionsGroupPreference
p {role = r}, Maybe GroupMemberRole
role)

instance GroupFeatureRoleI 'GFDirectMessages

instance GroupFeatureRoleI 'GFFullDelete

instance GroupFeatureRoleI 'GFVoice

instance GroupFeatureRoleI 'GFFiles

instance GroupFeatureRoleI 'GFSimplexLinks

instance GroupFeatureRoleI 'GFSessions

groupPrefStateText :: HasField "enable" p GroupFeatureEnabled => GroupFeature -> p -> Maybe Int -> Maybe GroupMemberRole -> Text
groupPrefStateText :: forall p.
HasField "enable" p GroupFeatureEnabled =>
GroupFeature -> p -> Maybe Int -> Maybe GroupMemberRole -> Text
groupPrefStateText GroupFeature
feature p
pref Maybe Int
param Maybe GroupMemberRole
role =
  let enabled :: GroupFeatureEnabled
enabled = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"enable" p
pref
      paramText :: Text
paramText = if GroupFeatureEnabled
enabled GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
forall a. Eq a => a -> a -> Bool
== GroupFeatureEnabled
FEOn then GroupFeature -> Maybe Int -> Text
groupParamText_ GroupFeature
feature Maybe Int
param else Text
""
      roleText :: Text
roleText = Text -> (GroupMemberRole -> Text) -> Maybe GroupMemberRole -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
"" (\GroupMemberRole
r -> Text
" for " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ByteString -> Text
safeDecodeUtf8 (GroupMemberRole -> ByteString
forall a. StrEncoding a => a -> ByteString
strEncode GroupMemberRole
r) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"s") Maybe GroupMemberRole
role
   in GroupFeature -> Text
groupFeatureNameText GroupFeature
feature Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
": " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ByteString -> Text
safeDecodeUtf8 (GroupFeatureEnabled -> ByteString
forall a. StrEncoding a => a -> ByteString
strEncode GroupFeatureEnabled
enabled) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
paramText Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
roleText

groupParamText_ :: GroupFeature -> Maybe Int -> Text
groupParamText_ :: GroupFeature -> Maybe Int -> Text
groupParamText_ GroupFeature
feature Maybe Int
param = case GroupFeature
feature of
  GroupFeature
GFTimedMessages -> Text -> (Int -> Text) -> Maybe Int -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
"" (\Int
p -> Text
" (" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
timedTTLText Int
p Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
")") Maybe Int
param
  GroupFeature
_ -> Text
""

groupPreferenceText :: forall f. GroupFeatureI f => GroupFeaturePreference f -> Text
groupPreferenceText :: forall (f :: GroupFeature).
GroupFeatureI f =>
GroupFeaturePreference f -> Text
groupPreferenceText GroupFeaturePreference f
pref =
  let feature :: GroupFeature
feature = SGroupFeature f -> GroupFeature
forall (f :: GroupFeature). SGroupFeature f -> GroupFeature
toGroupFeature (SGroupFeature f -> GroupFeature)
-> SGroupFeature f -> GroupFeature
forall a b. (a -> b) -> a -> b
$ forall (f :: GroupFeature). GroupFeatureI f => SGroupFeature f
sGroupFeature @f
   in GroupFeature
-> GroupFeaturePreference f
-> Maybe Int
-> Maybe GroupMemberRole
-> Text
forall p.
HasField "enable" p GroupFeatureEnabled =>
GroupFeature -> p -> Maybe Int -> Maybe GroupMemberRole -> Text
groupPrefStateText GroupFeature
feature GroupFeaturePreference f
pref (GroupFeaturePreference f -> Maybe Int
forall (f :: GroupFeature).
GroupFeatureI f =>
GroupFeaturePreference f -> Maybe Int
groupPrefParam GroupFeaturePreference f
pref) (GroupFeaturePreference f -> Maybe GroupMemberRole
forall (f :: GroupFeature).
GroupFeatureI f =>
GroupFeaturePreference f -> Maybe GroupMemberRole
groupPrefRole GroupFeaturePreference f
pref)

timedTTLText :: Int -> Text
timedTTLText :: Int -> Text
timedTTLText Int
0 = Text
"0 sec"
timedTTLText Int
ttl = do
  let (Int
m', Int
s) = Int
ttl Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
60
      (Int
h', Int
m) = Int
m' Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
60
      (Int
d', Int
h) = Int
h' Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
24
      (Int
mm, Int
d) = Int
d' Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
30
  String -> Text
T.pack (String -> Text) -> ([String] -> String) -> [String] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> String
unwords ([String] -> Text) -> [String] -> Text
forall a b. (a -> b) -> a -> b
$
    [Int -> String
forall {a}. (Eq a, Num a, Show a) => a -> String
mms Int
mm | Int
mm Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0] [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Int -> String
forall {a}. (Eq a, Num a, Show a) => a -> String
ds Int
d | Int
d Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0] [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Int -> String
forall {a}. (Eq a, Num a, Show a) => a -> String
hs Int
h | Int
h Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0] [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Int -> String
forall {a}. Show a => a -> String
ms Int
m | Int
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0] [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Int -> String
forall {a}. Show a => a -> String
ss Int
s | Int
s Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0]
  where
    ss :: a -> String
ss a
s = a -> String
forall {a}. Show a => a -> String
show a
s String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" sec"
    ms :: a -> String
ms a
m = a -> String
forall {a}. Show a => a -> String
show a
m String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" min"
    hs :: a -> String
hs a
1 = String
"1 hour"
    hs a
h = a -> String
forall {a}. Show a => a -> String
show a
h String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" hours"
    ds :: a -> String
ds a
1 = String
"1 day"
    ds a
7 = String
"1 week"
    ds a
14 = String
"2 weeks"
    ds a
d = a -> String
forall {a}. Show a => a -> String
show a
d String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" days"
    mms :: a -> String
mms a
1 = String
"1 month"
    mms a
mm = a -> String
forall {a}. Show a => a -> String
show a
mm String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" months"

toGroupPreference :: GroupFeatureI f => GroupFeaturePreference f -> GroupPreference
toGroupPreference :: forall (f :: GroupFeature).
GroupFeatureI f =>
GroupFeaturePreference f -> GroupPreference
toGroupPreference GroupFeaturePreference f
p = GroupPreference {enable :: GroupFeatureEnabled
enable = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"enable" GroupFeaturePreference f
p}

data FeatureAllowed
  = FAAlways -- allow unconditionally
  | FAYes -- allow, if peer allows it
  | FANo -- do not allow
  deriving (FeatureAllowed -> FeatureAllowed -> Bool
(FeatureAllowed -> FeatureAllowed -> Bool)
-> (FeatureAllowed -> FeatureAllowed -> Bool) -> Eq FeatureAllowed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FeatureAllowed -> FeatureAllowed -> Bool
== :: FeatureAllowed -> FeatureAllowed -> Bool
$c/= :: FeatureAllowed -> FeatureAllowed -> Bool
/= :: FeatureAllowed -> FeatureAllowed -> Bool
Eq, Int -> FeatureAllowed -> ShowS
[FeatureAllowed] -> ShowS
FeatureAllowed -> String
(Int -> FeatureAllowed -> ShowS)
-> (FeatureAllowed -> String)
-> ([FeatureAllowed] -> ShowS)
-> Show FeatureAllowed
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FeatureAllowed -> ShowS
showsPrec :: Int -> FeatureAllowed -> ShowS
$cshow :: FeatureAllowed -> String
show :: FeatureAllowed -> String
$cshowList :: [FeatureAllowed] -> ShowS
showList :: [FeatureAllowed] -> ShowS
Show)

instance FromField FeatureAllowed where fromField :: FieldParser FeatureAllowed
fromField = (ByteString -> Either String FeatureAllowed)
-> FieldParser FeatureAllowed
forall k.
Typeable k =>
(ByteString -> Either String k) -> FieldParser k
blobFieldDecoder ByteString -> Either String FeatureAllowed
forall a. StrEncoding a => ByteString -> Either String a
strDecode

instance ToField FeatureAllowed where toField :: FeatureAllowed -> SQLData
toField = ByteString -> SQLData
forall a. ToField a => a -> SQLData
toField (ByteString -> SQLData)
-> (FeatureAllowed -> ByteString) -> FeatureAllowed -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FeatureAllowed -> ByteString
forall a. StrEncoding a => a -> ByteString
strEncode

instance StrEncoding FeatureAllowed where
  strEncode :: FeatureAllowed -> ByteString
strEncode = \case
    FeatureAllowed
FAAlways -> ByteString
"always"
    FeatureAllowed
FAYes -> ByteString
"yes"
    FeatureAllowed
FANo -> ByteString
"no"
  strDecode :: ByteString -> Either String FeatureAllowed
strDecode = \case
    ByteString
"always" -> FeatureAllowed -> Either String FeatureAllowed
forall a b. b -> Either a b
Right FeatureAllowed
FAAlways
    ByteString
"yes" -> FeatureAllowed -> Either String FeatureAllowed
forall a b. b -> Either a b
Right FeatureAllowed
FAYes
    ByteString
"no" -> FeatureAllowed -> Either String FeatureAllowed
forall a b. b -> Either a b
Right FeatureAllowed
FANo
    ByteString
r -> String -> Either String FeatureAllowed
forall a b. a -> Either a b
Left (String -> Either String FeatureAllowed)
-> String -> Either String FeatureAllowed
forall a b. (a -> b) -> a -> b
$ String
"bad FeatureAllowed " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ByteString -> String
B.unpack ByteString
r
  strP :: Parser FeatureAllowed
strP = ByteString -> Either String FeatureAllowed
forall a. StrEncoding a => ByteString -> Either String a
strDecode (ByteString -> Either String FeatureAllowed)
-> Parser ByteString ByteString -> Parser FeatureAllowed
forall (m :: * -> *) a b.
MonadFail m =>
(a -> Either String b) -> m a -> m b
<$?> Parser ByteString ByteString
A.takeByteString

instance FromJSON FeatureAllowed where
  parseJSON :: Value -> Parser FeatureAllowed
parseJSON = String -> Value -> Parser FeatureAllowed
forall a. StrEncoding a => String -> Value -> Parser a
strParseJSON String
"FeatureAllowed"

instance ToJSON FeatureAllowed where
  toJSON :: FeatureAllowed -> Value
toJSON = FeatureAllowed -> Value
forall a. StrEncoding a => a -> Value
strToJSON
  toEncoding :: FeatureAllowed -> Encoding
toEncoding = FeatureAllowed -> Encoding
forall a. StrEncoding a => a -> Encoding
strToJEncoding

data GroupFeatureEnabled = FEOn | FEOff
  deriving (GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
(GroupFeatureEnabled -> GroupFeatureEnabled -> Bool)
-> (GroupFeatureEnabled -> GroupFeatureEnabled -> Bool)
-> Eq GroupFeatureEnabled
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
== :: GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
$c/= :: GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
/= :: GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
Eq, Int -> GroupFeatureEnabled -> ShowS
[GroupFeatureEnabled] -> ShowS
GroupFeatureEnabled -> String
(Int -> GroupFeatureEnabled -> ShowS)
-> (GroupFeatureEnabled -> String)
-> ([GroupFeatureEnabled] -> ShowS)
-> Show GroupFeatureEnabled
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupFeatureEnabled -> ShowS
showsPrec :: Int -> GroupFeatureEnabled -> ShowS
$cshow :: GroupFeatureEnabled -> String
show :: GroupFeatureEnabled -> String
$cshowList :: [GroupFeatureEnabled] -> ShowS
showList :: [GroupFeatureEnabled] -> ShowS
Show)

instance FromField GroupFeatureEnabled where fromField :: FieldParser GroupFeatureEnabled
fromField = (ByteString -> Either String GroupFeatureEnabled)
-> FieldParser GroupFeatureEnabled
forall k.
Typeable k =>
(ByteString -> Either String k) -> FieldParser k
blobFieldDecoder ByteString -> Either String GroupFeatureEnabled
forall a. StrEncoding a => ByteString -> Either String a
strDecode

instance ToField GroupFeatureEnabled where toField :: GroupFeatureEnabled -> SQLData
toField = ByteString -> SQLData
forall a. ToField a => a -> SQLData
toField (ByteString -> SQLData)
-> (GroupFeatureEnabled -> ByteString)
-> GroupFeatureEnabled
-> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GroupFeatureEnabled -> ByteString
forall a. StrEncoding a => a -> ByteString
strEncode

instance StrEncoding GroupFeatureEnabled where
  strEncode :: GroupFeatureEnabled -> ByteString
strEncode = \case
    GroupFeatureEnabled
FEOn -> ByteString
"on"
    GroupFeatureEnabled
FEOff -> ByteString
"off"
  strDecode :: ByteString -> Either String GroupFeatureEnabled
strDecode = \case
    ByteString
"on" -> GroupFeatureEnabled -> Either String GroupFeatureEnabled
forall a b. b -> Either a b
Right GroupFeatureEnabled
FEOn
    ByteString
"off" -> GroupFeatureEnabled -> Either String GroupFeatureEnabled
forall a b. b -> Either a b
Right GroupFeatureEnabled
FEOff
    ByteString
r -> String -> Either String GroupFeatureEnabled
forall a b. a -> Either a b
Left (String -> Either String GroupFeatureEnabled)
-> String -> Either String GroupFeatureEnabled
forall a b. (a -> b) -> a -> b
$ String
"bad GroupFeatureEnabled " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ByteString -> String
B.unpack ByteString
r
  strP :: Parser GroupFeatureEnabled
strP = ByteString -> Either String GroupFeatureEnabled
forall a. StrEncoding a => ByteString -> Either String a
strDecode (ByteString -> Either String GroupFeatureEnabled)
-> Parser ByteString ByteString -> Parser GroupFeatureEnabled
forall (m :: * -> *) a b.
MonadFail m =>
(a -> Either String b) -> m a -> m b
<$?> (Char -> Bool) -> Parser ByteString ByteString
A.takeTill (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ')

instance FromJSON GroupFeatureEnabled where
  parseJSON :: Value -> Parser GroupFeatureEnabled
parseJSON = String -> Value -> Parser GroupFeatureEnabled
forall a. StrEncoding a => String -> Value -> Parser a
strParseJSON String
"GroupFeatureEnabled"

instance ToJSON GroupFeatureEnabled where
  toJSON :: GroupFeatureEnabled -> Value
toJSON = GroupFeatureEnabled -> Value
forall a. StrEncoding a => a -> Value
strToJSON
  toEncoding :: GroupFeatureEnabled -> Encoding
toEncoding = GroupFeatureEnabled -> Encoding
forall a. StrEncoding a => a -> Encoding
strToJEncoding

groupFeatureState :: GroupFeatureI f => GroupFeaturePreference f -> (GroupFeatureEnabled, Maybe Int, Maybe GroupMemberRole)
groupFeatureState :: forall (f :: GroupFeature).
GroupFeatureI f =>
GroupFeaturePreference f
-> (GroupFeatureEnabled, Maybe Int, Maybe GroupMemberRole)
groupFeatureState GroupFeaturePreference f
p =
  let enable :: GroupFeatureEnabled
enable = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"enable" GroupFeaturePreference f
p
      (Maybe Int
param, Maybe GroupMemberRole
role)
        | GroupFeatureEnabled
enable GroupFeatureEnabled -> GroupFeatureEnabled -> Bool
forall a. Eq a => a -> a -> Bool
== GroupFeatureEnabled
FEOn = (GroupFeaturePreference f -> Maybe Int
forall (f :: GroupFeature).
GroupFeatureI f =>
GroupFeaturePreference f -> Maybe Int
groupPrefParam GroupFeaturePreference f
p, GroupFeaturePreference f -> Maybe GroupMemberRole
forall (f :: GroupFeature).
GroupFeatureI f =>
GroupFeaturePreference f -> Maybe GroupMemberRole
groupPrefRole GroupFeaturePreference f
p)
        | Bool
otherwise = (Maybe Int
forall a. Maybe a
Nothing, Maybe GroupMemberRole
forall a. Maybe a
Nothing)
   in (GroupFeatureEnabled
enable, Maybe Int
param, Maybe GroupMemberRole
role)

mergePreferences :: Maybe Preferences -> Maybe Preferences -> Bool -> FullPreferences
mergePreferences :: Maybe Preferences -> Maybe Preferences -> Bool -> FullPreferences
mergePreferences Maybe Preferences
contactPrefs Maybe Preferences
userPreferences Bool
canFallbackToUserTTL =
  FullPreferences
    { timedMessages :: TimedMessagesPreference
timedMessages = if Bool
canFallbackToUserTTL then SChatFeature 'CFTimedMessages -> FeaturePreference 'CFTimedMessages
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFTimedMessages
SCFTimedMessages else TimedMessagesPreference
timedPrefNoTTLFallback,
      fullDelete :: FullDeletePreference
fullDelete = SChatFeature 'CFFullDelete -> FeaturePreference 'CFFullDelete
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFFullDelete
SCFFullDelete,
      reactions :: ReactionsPreference
reactions = SChatFeature 'CFReactions -> FeaturePreference 'CFReactions
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFReactions
SCFReactions,
      voice :: VoicePreference
voice = SChatFeature 'CFVoice -> FeaturePreference 'CFVoice
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFVoice
SCFVoice,
      files :: FilesPreference
files = SChatFeature 'CFFiles -> FeaturePreference 'CFFiles
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFFiles
SCFFiles,
      calls :: CallsPreference
calls = SChatFeature 'CFCalls -> FeaturePreference 'CFCalls
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFCalls
SCFCalls,
      sessions :: SessionsPreference
sessions = SChatFeature 'CFSessions -> FeaturePreference 'CFSessions
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFSessions
SCFSessions,
      commands :: ListDef ChatBotCommand
commands = [ChatBotCommand] -> ListDef ChatBotCommand
forall a. [a] -> ListDef a
ListDef ([ChatBotCommand] -> ListDef ChatBotCommand)
-> [ChatBotCommand] -> ListDef ChatBotCommand
forall a b. (a -> b) -> a -> b
$ [ChatBotCommand] -> Maybe [ChatBotCommand] -> [ChatBotCommand]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [ChatBotCommand] -> [ChatBotCommand])
-> Maybe [ChatBotCommand] -> [ChatBotCommand]
forall a b. (a -> b) -> a -> b
$ (Maybe Preferences
contactPrefs Maybe Preferences
-> (Preferences -> Maybe [ChatBotCommand])
-> Maybe [ChatBotCommand]
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Preferences -> Maybe [ChatBotCommand]
forall p. HasCommands p => p -> Maybe [ChatBotCommand]
commands_) Maybe [ChatBotCommand]
-> Maybe [ChatBotCommand] -> Maybe [ChatBotCommand]
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Maybe Preferences
userPreferences Maybe Preferences
-> (Preferences -> Maybe [ChatBotCommand])
-> Maybe [ChatBotCommand]
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Preferences -> Maybe [ChatBotCommand]
forall p. HasCommands p => p -> Maybe [ChatBotCommand]
commands_)
    }
  where
    timedPrefNoTTLFallback :: TimedMessagesPreference
    timedPrefNoTTLFallback :: TimedMessagesPreference
timedPrefNoTTLFallback =
      let allow :: FeatureAllowed
allow = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"allow" (TimedMessagesPreference -> FeatureAllowed)
-> TimedMessagesPreference -> FeatureAllowed
forall a b. (a -> b) -> a -> b
$ SChatFeature 'CFTimedMessages -> FeaturePreference 'CFTimedMessages
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFTimedMessages
SCFTimedMessages
          -- this is to avoid fallback to user level timed messages TTL even if there is no contact level override
          -- (specifically to avoid sending user level TTL to contacts without override on profile updates,
          -- to make it "consistently not work" for all contacts, as we're using override mechanism to track TTL
          -- for new and updated contacts, even though it's not really user's override)
          ttlOverride :: Maybe Int
ttlOverride = Maybe Preferences
contactPrefs Maybe Preferences
-> (Preferences -> Maybe TimedMessagesPreference)
-> Maybe TimedMessagesPreference
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SChatFeature 'CFTimedMessages
-> Preferences -> Maybe (FeaturePreference 'CFTimedMessages)
forall (f :: ChatFeature).
SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
chatPrefSel SChatFeature 'CFTimedMessages
SCFTimedMessages Maybe TimedMessagesPreference
-> (TimedMessagesPreference -> Maybe Int) -> Maybe Int
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\TimedMessagesPreference {Maybe Int
ttl :: TimedMessagesPreference -> Maybe Int
ttl :: Maybe Int
ttl} -> Maybe Int
ttl)
       in TimedMessagesPreference {FeatureAllowed
allow :: FeatureAllowed
allow :: FeatureAllowed
allow, ttl :: Maybe Int
ttl = Maybe Int
ttlOverride}
    pref :: SChatFeature f -> FeaturePreference f
    pref :: forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature f
f =
      let sel :: Preferences -> Maybe (FeaturePreference f)
sel = SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
forall (f :: ChatFeature).
SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
chatPrefSel SChatFeature f
f
       in FeaturePreference f
-> Maybe (FeaturePreference f) -> FeaturePreference f
forall a. a -> Maybe a -> a
fromMaybe (SChatFeature f -> FullPreferences -> FeaturePreference f
forall p (f :: ChatFeature).
PreferenceI p =>
SChatFeature f -> p -> FeaturePreference f
forall (f :: ChatFeature).
SChatFeature f -> FullPreferences -> FeaturePreference f
getPreference SChatFeature f
f FullPreferences
defaultChatPrefs) (Maybe (FeaturePreference f) -> FeaturePreference f)
-> Maybe (FeaturePreference f) -> FeaturePreference f
forall a b. (a -> b) -> a -> b
$ (Maybe Preferences
contactPrefs Maybe Preferences
-> (Preferences -> Maybe (FeaturePreference f))
-> Maybe (FeaturePreference f)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Preferences -> Maybe (FeaturePreference f)
sel) Maybe (FeaturePreference f)
-> Maybe (FeaturePreference f) -> Maybe (FeaturePreference f)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Maybe Preferences
userPreferences Maybe Preferences
-> (Preferences -> Maybe (FeaturePreference f))
-> Maybe (FeaturePreference f)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Preferences -> Maybe (FeaturePreference f)
sel)

fullPreferences' :: Maybe Preferences -> FullPreferences
fullPreferences' :: Maybe Preferences -> FullPreferences
fullPreferences' Maybe Preferences
userPreferences =
  FullPreferences
    { timedMessages :: TimedMessagesPreference
timedMessages = SChatFeature 'CFTimedMessages -> FeaturePreference 'CFTimedMessages
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFTimedMessages
SCFTimedMessages,
      fullDelete :: FullDeletePreference
fullDelete = SChatFeature 'CFFullDelete -> FeaturePreference 'CFFullDelete
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFFullDelete
SCFFullDelete,
      reactions :: ReactionsPreference
reactions = SChatFeature 'CFReactions -> FeaturePreference 'CFReactions
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFReactions
SCFReactions,
      voice :: VoicePreference
voice = SChatFeature 'CFVoice -> FeaturePreference 'CFVoice
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFVoice
SCFVoice,
      files :: FilesPreference
files = SChatFeature 'CFFiles -> FeaturePreference 'CFFiles
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFFiles
SCFFiles,
      calls :: CallsPreference
calls = SChatFeature 'CFCalls -> FeaturePreference 'CFCalls
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFCalls
SCFCalls,
      sessions :: SessionsPreference
sessions = SChatFeature 'CFSessions -> FeaturePreference 'CFSessions
forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature 'CFSessions
SCFSessions,
      commands :: ListDef ChatBotCommand
commands = [ChatBotCommand] -> ListDef ChatBotCommand
forall a. [a] -> ListDef a
ListDef ([ChatBotCommand] -> ListDef ChatBotCommand)
-> [ChatBotCommand] -> ListDef ChatBotCommand
forall a b. (a -> b) -> a -> b
$ [ChatBotCommand] -> Maybe [ChatBotCommand] -> [ChatBotCommand]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [ChatBotCommand] -> [ChatBotCommand])
-> Maybe [ChatBotCommand] -> [ChatBotCommand]
forall a b. (a -> b) -> a -> b
$ Maybe Preferences
userPreferences Maybe Preferences
-> (Preferences -> Maybe [ChatBotCommand])
-> Maybe [ChatBotCommand]
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Preferences -> Maybe [ChatBotCommand]
forall p. HasCommands p => p -> Maybe [ChatBotCommand]
commands_
    }
  where
    pref :: SChatFeature f -> FeaturePreference f
    pref :: forall (f :: ChatFeature). SChatFeature f -> FeaturePreference f
pref SChatFeature f
f =
      let sel :: Preferences -> Maybe (FeaturePreference f)
sel = SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
forall (f :: ChatFeature).
SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
chatPrefSel SChatFeature f
f
       in FeaturePreference f
-> Maybe (FeaturePreference f) -> FeaturePreference f
forall a. a -> Maybe a -> a
fromMaybe (SChatFeature f -> FullPreferences -> FeaturePreference f
forall p (f :: ChatFeature).
PreferenceI p =>
SChatFeature f -> p -> FeaturePreference f
forall (f :: ChatFeature).
SChatFeature f -> FullPreferences -> FeaturePreference f
getPreference SChatFeature f
f FullPreferences
defaultChatPrefs) (Maybe (FeaturePreference f) -> FeaturePreference f)
-> Maybe (FeaturePreference f) -> FeaturePreference f
forall a b. (a -> b) -> a -> b
$ (Maybe Preferences
userPreferences Maybe Preferences
-> (Preferences -> Maybe (FeaturePreference f))
-> Maybe (FeaturePreference f)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Preferences -> Maybe (FeaturePreference f)
sel)

mergeGroupPreferences :: Maybe GroupPreferences -> FullGroupPreferences
mergeGroupPreferences :: Maybe GroupPreferences -> FullGroupPreferences
mergeGroupPreferences Maybe GroupPreferences
groupPreferences =
  FullGroupPreferences
    { timedMessages :: TimedMessagesGroupPreference
timedMessages = SGroupFeature 'GFTimedMessages
-> GroupFeaturePreference 'GFTimedMessages
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFTimedMessages
SGFTimedMessages,
      directMessages :: DirectMessagesGroupPreference
directMessages = SGroupFeature 'GFDirectMessages
-> GroupFeaturePreference 'GFDirectMessages
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFDirectMessages
SGFDirectMessages,
      fullDelete :: FullDeleteGroupPreference
fullDelete = SGroupFeature 'GFFullDelete -> GroupFeaturePreference 'GFFullDelete
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFFullDelete
SGFFullDelete,
      reactions :: ReactionsGroupPreference
reactions = SGroupFeature 'GFReactions -> GroupFeaturePreference 'GFReactions
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFReactions
SGFReactions,
      voice :: VoiceGroupPreference
voice = SGroupFeature 'GFVoice -> GroupFeaturePreference 'GFVoice
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFVoice
SGFVoice,
      files :: FilesGroupPreference
files = SGroupFeature 'GFFiles -> GroupFeaturePreference 'GFFiles
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFFiles
SGFFiles,
      simplexLinks :: SimplexLinksGroupPreference
simplexLinks = SGroupFeature 'GFSimplexLinks
-> GroupFeaturePreference 'GFSimplexLinks
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFSimplexLinks
SGFSimplexLinks,
      reports :: ReportsGroupPreference
reports = SGroupFeature 'GFReports -> GroupFeaturePreference 'GFReports
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFReports
SGFReports,
      history :: HistoryGroupPreference
history = SGroupFeature 'GFHistory -> GroupFeaturePreference 'GFHistory
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFHistory
SGFHistory,
      sessions :: SessionsGroupPreference
sessions = SGroupFeature 'GFSessions -> GroupFeaturePreference 'GFSessions
forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature 'GFSessions
SGFSessions,
      commands :: ListDef ChatBotCommand
commands = [ChatBotCommand] -> ListDef ChatBotCommand
forall a. [a] -> ListDef a
ListDef ([ChatBotCommand] -> ListDef ChatBotCommand)
-> [ChatBotCommand] -> ListDef ChatBotCommand
forall a b. (a -> b) -> a -> b
$ [ChatBotCommand] -> Maybe [ChatBotCommand] -> [ChatBotCommand]
forall a. a -> Maybe a -> a
fromMaybe [] (Maybe [ChatBotCommand] -> [ChatBotCommand])
-> Maybe [ChatBotCommand] -> [ChatBotCommand]
forall a b. (a -> b) -> a -> b
$ Maybe GroupPreferences
groupPreferences Maybe GroupPreferences
-> (GroupPreferences -> Maybe [ChatBotCommand])
-> Maybe [ChatBotCommand]
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= GroupPreferences -> Maybe [ChatBotCommand]
forall p. HasCommands p => p -> Maybe [ChatBotCommand]
commands_
    }
  where
    pref :: SGroupFeature f -> GroupFeaturePreference f
    pref :: forall (f :: GroupFeature).
SGroupFeature f -> GroupFeaturePreference f
pref SGroupFeature f
pt = GroupFeaturePreference f
-> Maybe (GroupFeaturePreference f) -> GroupFeaturePreference f
forall a. a -> Maybe a -> a
fromMaybe (SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
pt FullGroupPreferences
defaultGroupPrefs) (Maybe GroupPreferences
groupPreferences Maybe GroupPreferences
-> (GroupPreferences -> Maybe (GroupFeaturePreference f))
-> Maybe (GroupFeaturePreference f)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SGroupFeature f
-> GroupPreferences -> Maybe (GroupFeaturePreference f)
forall (f :: GroupFeature).
SGroupFeature f
-> GroupPreferences -> Maybe (GroupFeaturePreference f)
groupPrefSel SGroupFeature f
pt)

toGroupPreferences :: FullGroupPreferences -> GroupPreferences
toGroupPreferences :: FullGroupPreferences -> GroupPreferences
toGroupPreferences groupPreferences :: FullGroupPreferences
groupPreferences@FullGroupPreferences {commands :: FullGroupPreferences -> ListDef ChatBotCommand
commands = ListDef [ChatBotCommand]
cmds} =
  GroupPreferences
    { timedMessages :: Maybe TimedMessagesGroupPreference
timedMessages = SGroupFeature 'GFTimedMessages
-> Maybe (GroupFeaturePreference 'GFTimedMessages)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFTimedMessages
SGFTimedMessages,
      directMessages :: Maybe DirectMessagesGroupPreference
directMessages = SGroupFeature 'GFDirectMessages
-> Maybe (GroupFeaturePreference 'GFDirectMessages)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFDirectMessages
SGFDirectMessages,
      fullDelete :: Maybe FullDeleteGroupPreference
fullDelete = SGroupFeature 'GFFullDelete
-> Maybe (GroupFeaturePreference 'GFFullDelete)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFFullDelete
SGFFullDelete,
      reactions :: Maybe ReactionsGroupPreference
reactions = SGroupFeature 'GFReactions
-> Maybe (GroupFeaturePreference 'GFReactions)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFReactions
SGFReactions,
      voice :: Maybe VoiceGroupPreference
voice = SGroupFeature 'GFVoice -> Maybe (GroupFeaturePreference 'GFVoice)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFVoice
SGFVoice,
      files :: Maybe FilesGroupPreference
files = SGroupFeature 'GFFiles -> Maybe (GroupFeaturePreference 'GFFiles)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFFiles
SGFFiles,
      simplexLinks :: Maybe SimplexLinksGroupPreference
simplexLinks = SGroupFeature 'GFSimplexLinks
-> Maybe (GroupFeaturePreference 'GFSimplexLinks)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFSimplexLinks
SGFSimplexLinks,
      reports :: Maybe ReportsGroupPreference
reports = SGroupFeature 'GFReports
-> Maybe (GroupFeaturePreference 'GFReports)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFReports
SGFReports,
      history :: Maybe HistoryGroupPreference
history = SGroupFeature 'GFHistory
-> Maybe (GroupFeaturePreference 'GFHistory)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFHistory
SGFHistory,
      sessions :: Maybe SessionsGroupPreference
sessions = SGroupFeature 'GFSessions
-> Maybe (GroupFeaturePreference 'GFSessions)
forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature 'GFSessions
SGFSessions,
      commands :: Maybe [ChatBotCommand]
commands = [ChatBotCommand] -> Maybe [ChatBotCommand]
forall a. a -> Maybe a
Just [ChatBotCommand]
cmds
    }
  where
    pref :: SGroupFeature f -> Maybe (GroupFeaturePreference f)
    pref :: forall (f :: GroupFeature).
SGroupFeature f -> Maybe (GroupFeaturePreference f)
pref SGroupFeature f
f = GroupFeaturePreference f -> Maybe (GroupFeaturePreference f)
forall a. a -> Maybe a
Just (GroupFeaturePreference f -> Maybe (GroupFeaturePreference f))
-> GroupFeaturePreference f -> Maybe (GroupFeaturePreference f)
forall a b. (a -> b) -> a -> b
$ SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
forall p (f :: GroupFeature).
GroupPreferenceI p =>
SGroupFeature f -> p -> GroupFeaturePreference f
forall (f :: GroupFeature).
SGroupFeature f -> FullGroupPreferences -> GroupFeaturePreference f
getGroupPreference SGroupFeature f
f FullGroupPreferences
groupPreferences

data PrefEnabled = PrefEnabled {PrefEnabled -> Bool
forUser :: Bool, PrefEnabled -> Bool
forContact :: Bool}
  deriving (PrefEnabled -> PrefEnabled -> Bool
(PrefEnabled -> PrefEnabled -> Bool)
-> (PrefEnabled -> PrefEnabled -> Bool) -> Eq PrefEnabled
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrefEnabled -> PrefEnabled -> Bool
== :: PrefEnabled -> PrefEnabled -> Bool
$c/= :: PrefEnabled -> PrefEnabled -> Bool
/= :: PrefEnabled -> PrefEnabled -> Bool
Eq, Int -> PrefEnabled -> ShowS
[PrefEnabled] -> ShowS
PrefEnabled -> String
(Int -> PrefEnabled -> ShowS)
-> (PrefEnabled -> String)
-> ([PrefEnabled] -> ShowS)
-> Show PrefEnabled
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrefEnabled -> ShowS
showsPrec :: Int -> PrefEnabled -> ShowS
$cshow :: PrefEnabled -> String
show :: PrefEnabled -> String
$cshowList :: [PrefEnabled] -> ShowS
showList :: [PrefEnabled] -> ShowS
Show)

prefEnabled :: FeatureI f => Bool -> FeaturePreference f -> FeaturePreference f -> PrefEnabled
prefEnabled :: forall (f :: ChatFeature).
FeatureI f =>
Bool -> FeaturePreference f -> FeaturePreference f -> PrefEnabled
prefEnabled Bool
asymmetric FeaturePreference f
user FeaturePreference f
contact = case (forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"allow" FeaturePreference f
user, forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"allow" FeaturePreference f
contact) of
  (FeatureAllowed
FAAlways, FeatureAllowed
FANo) -> PrefEnabled {forUser :: Bool
forUser = Bool
False, forContact :: Bool
forContact = Bool
asymmetric}
  (FeatureAllowed
FANo, FeatureAllowed
FAAlways) -> PrefEnabled {forUser :: Bool
forUser = Bool
asymmetric, forContact :: Bool
forContact = Bool
False}
  (FeatureAllowed
_, FeatureAllowed
FANo) -> Bool -> Bool -> PrefEnabled
PrefEnabled Bool
False Bool
False
  (FeatureAllowed
FANo, FeatureAllowed
_) -> Bool -> Bool -> PrefEnabled
PrefEnabled Bool
False Bool
False
  (FeatureAllowed, FeatureAllowed)
_ -> Bool -> Bool -> PrefEnabled
PrefEnabled Bool
True Bool
True

prefStateText :: ChatFeature -> FeatureAllowed -> Maybe Int -> Text
prefStateText :: ChatFeature -> FeatureAllowed -> Maybe Int -> Text
prefStateText ChatFeature
feature FeatureAllowed
allowed Maybe Int
param = case FeatureAllowed
allowed of
  FeatureAllowed
FANo -> Text
"cancelled " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ChatFeature -> Text
chatFeatureNameText ChatFeature
feature
  FeatureAllowed
_ -> Text
"offered " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ChatFeature -> Text
chatFeatureNameText ChatFeature
feature Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ChatFeature -> Maybe Int -> Text
paramText_ ChatFeature
feature Maybe Int
param

featureStateText :: ChatFeature -> PrefEnabled -> Maybe Int -> Text
featureStateText :: ChatFeature -> PrefEnabled -> Maybe Int -> Text
featureStateText ChatFeature
feature PrefEnabled
enabled Maybe Int
param =
  ChatFeature -> Text
chatFeatureNameText ChatFeature
feature Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
": " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ChatFeature -> PrefEnabled -> Maybe Int -> Text
prefEnabledToText ChatFeature
feature PrefEnabled
enabled Maybe Int
param Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> case PrefEnabled
enabled of
    PrefEnabled {forUser :: PrefEnabled -> Bool
forUser = Bool
True} -> ChatFeature -> Maybe Int -> Text
paramText_ ChatFeature
feature Maybe Int
param
    PrefEnabled
_ -> Text
""

paramText_ :: ChatFeature -> Maybe Int -> Text
paramText_ :: ChatFeature -> Maybe Int -> Text
paramText_ ChatFeature
feature Maybe Int
param = case ChatFeature
feature of
  ChatFeature
CFTimedMessages -> Text -> (Int -> Text) -> Maybe Int -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
"" (\Int
p -> Text
" (" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
timedTTLText Int
p Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
")") Maybe Int
param
  ChatFeature
_ -> Text
""

prefEnabledToText :: ChatFeature -> PrefEnabled -> Maybe Int -> Text
prefEnabledToText :: ChatFeature -> PrefEnabled -> Maybe Int -> Text
prefEnabledToText ChatFeature
f PrefEnabled
enabled Maybe Int
param = case PrefEnabled
enabled of
  PrefEnabled Bool
True Bool
True -> Text
enabledStr
  PrefEnabled Bool
False Bool
False -> Text
"off"
  PrefEnabled {forUser :: PrefEnabled -> Bool
forUser = Bool
True, forContact :: PrefEnabled -> Bool
forContact = Bool
False} -> Text
enabledStr Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" for you"
  PrefEnabled {forUser :: PrefEnabled -> Bool
forUser = Bool
False, forContact :: PrefEnabled -> Bool
forContact = Bool
True} -> Text
enabledStr Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" for contact"
  where
    enabledStr :: Text
enabledStr = case ChatFeature
f of
      ChatFeature
CFTimedMessages -> if Maybe Int -> Bool
forall a. Maybe a -> Bool
isJust Maybe Int
param then Text
"enabled" else Text
"allowed"
      ChatFeature
_ -> Text
"enabled"

preferenceText :: forall f. FeatureI f => FeaturePreference f -> Text
preferenceText :: forall (f :: ChatFeature).
FeatureI f =>
FeaturePreference f -> Text
preferenceText FeaturePreference f
p =
  let feature :: ChatFeature
feature = SChatFeature f -> ChatFeature
forall (f :: ChatFeature). SChatFeature f -> ChatFeature
chatFeature (SChatFeature f -> ChatFeature) -> SChatFeature f -> ChatFeature
forall a b. (a -> b) -> a -> b
$ forall (f :: ChatFeature). FeatureI f => SChatFeature f
sFeature @f
      allowed :: FeatureAllowed
allowed = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"allow" FeaturePreference f
p
      paramText :: Text
paramText = if FeatureAllowed
allowed FeatureAllowed -> FeatureAllowed -> Bool
forall a. Eq a => a -> a -> Bool
== FeatureAllowed
FAAlways Bool -> Bool -> Bool
|| FeatureAllowed
allowed FeatureAllowed -> FeatureAllowed -> Bool
forall a. Eq a => a -> a -> Bool
== FeatureAllowed
FAYes then ChatFeature -> Maybe Int -> Text
paramText_ ChatFeature
feature (FeaturePreference f -> Maybe Int
forall (f :: ChatFeature).
FeatureI f =>
FeaturePreference f -> Maybe Int
prefParam FeaturePreference f
p) else Text
""
   in ByteString -> Text
safeDecodeUtf8 (FeatureAllowed -> ByteString
forall a. StrEncoding a => a -> ByteString
strEncode FeatureAllowed
allowed) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
paramText

featureState :: FeatureI f => ContactUserPreference (FeaturePreference f) -> (PrefEnabled, Maybe Int)
featureState :: forall (f :: ChatFeature).
FeatureI f =>
ContactUserPreference (FeaturePreference f)
-> (PrefEnabled, Maybe Int)
featureState ContactUserPreference {PrefEnabled
enabled :: forall p. ContactUserPreference p -> PrefEnabled
enabled :: PrefEnabled
enabled, ContactUserPref (FeaturePreference f)
userPreference :: forall p. ContactUserPreference p -> ContactUserPref p
userPreference :: ContactUserPref (FeaturePreference f)
userPreference} =
  let param :: Maybe Int
param = if PrefEnabled -> Bool
forUser PrefEnabled
enabled then FeaturePreference f -> Maybe Int
forall (f :: ChatFeature).
FeatureI f =>
FeaturePreference f -> Maybe Int
prefParam (FeaturePreference f -> Maybe Int)
-> FeaturePreference f -> Maybe Int
forall a b. (a -> b) -> a -> b
$ ContactUserPref (FeaturePreference f) -> FeaturePreference f
forall p. ContactUserPref p -> p
preference ContactUserPref (FeaturePreference f)
userPreference else Maybe Int
forall a. Maybe a
Nothing
   in (PrefEnabled
enabled, Maybe Int
param)

preferenceState :: FeatureI f => FeaturePreference f -> (FeatureAllowed, Maybe Int)
preferenceState :: forall (f :: ChatFeature).
FeatureI f =>
FeaturePreference f -> (FeatureAllowed, Maybe Int)
preferenceState FeaturePreference f
pref =
  let allow :: FeatureAllowed
allow = forall {k} (x :: k) r a. HasField x r a => r -> a
forall (x :: Symbol) r a. HasField x r a => r -> a
getField @"allow" FeaturePreference f
pref
      param :: Maybe Int
param = if FeatureAllowed
allow FeatureAllowed -> FeatureAllowed -> Bool
forall a. Eq a => a -> a -> Bool
== FeatureAllowed
FAAlways Bool -> Bool -> Bool
|| FeatureAllowed
allow FeatureAllowed -> FeatureAllowed -> Bool
forall a. Eq a => a -> a -> Bool
== FeatureAllowed
FAYes then FeaturePreference f -> Maybe Int
forall (f :: ChatFeature).
FeatureI f =>
FeaturePreference f -> Maybe Int
prefParam FeaturePreference f
pref else Maybe Int
forall a. Maybe a
Nothing
   in (FeatureAllowed
allow, Maybe Int
param)

getContactUserPreference :: SChatFeature f -> ContactUserPreferences -> ContactUserPreference (FeaturePreference f)
getContactUserPreference :: forall (f :: ChatFeature).
SChatFeature f
-> ContactUserPreferences
-> ContactUserPreference (FeaturePreference f)
getContactUserPreference SChatFeature f
f ContactUserPreferences {ContactUserPreference TimedMessagesPreference
timedMessages :: ContactUserPreferences
-> ContactUserPreference TimedMessagesPreference
timedMessages :: ContactUserPreference TimedMessagesPreference
timedMessages, ContactUserPreference FullDeletePreference
fullDelete :: ContactUserPreferences
-> ContactUserPreference FullDeletePreference
fullDelete :: ContactUserPreference FullDeletePreference
fullDelete, ContactUserPreference ReactionsPreference
reactions :: ContactUserPreferences -> ContactUserPreference ReactionsPreference
reactions :: ContactUserPreference ReactionsPreference
reactions, ContactUserPreference VoicePreference
voice :: ContactUserPreferences -> ContactUserPreference VoicePreference
voice :: ContactUserPreference VoicePreference
voice, ContactUserPreference FilesPreference
files :: ContactUserPreferences -> ContactUserPreference FilesPreference
files :: ContactUserPreference FilesPreference
files, ContactUserPreference CallsPreference
calls :: ContactUserPreferences -> ContactUserPreference CallsPreference
calls :: ContactUserPreference CallsPreference
calls, ContactUserPreference SessionsPreference
sessions :: ContactUserPreferences -> ContactUserPreference SessionsPreference
sessions :: ContactUserPreference SessionsPreference
sessions} = case SChatFeature f
f of
  SChatFeature f
SCFTimedMessages -> ContactUserPreference (FeaturePreference f)
ContactUserPreference TimedMessagesPreference
timedMessages
  SChatFeature f
SCFFullDelete -> ContactUserPreference (FeaturePreference f)
ContactUserPreference FullDeletePreference
fullDelete
  SChatFeature f
SCFReactions -> ContactUserPreference (FeaturePreference f)
ContactUserPreference ReactionsPreference
reactions
  SChatFeature f
SCFVoice -> ContactUserPreference (FeaturePreference f)
ContactUserPreference VoicePreference
voice
  SChatFeature f
SCFFiles -> ContactUserPreference (FeaturePreference f)
ContactUserPreference FilesPreference
files
  SChatFeature f
SCFCalls -> ContactUserPreference (FeaturePreference f)
ContactUserPreference CallsPreference
calls
  SChatFeature f
SCFSessions -> ContactUserPreference (FeaturePreference f)
ContactUserPreference SessionsPreference
sessions

$(J.deriveJSON (enumJSON $ dropPrefix "CF") ''ChatFeature)

$(J.deriveJSON (enumJSON $ dropPrefix "GF") ''GroupFeature)

$(J.deriveJSON defaultJSON ''TimedMessagesPreference)

$(J.deriveJSON defaultJSON ''FullDeletePreference)

$(J.deriveJSON defaultJSON ''ReactionsPreference)

$(J.deriveJSON defaultJSON ''VoicePreference)

$(J.deriveToJSON defaultJSON ''FilesPreference)

instance FromJSON FilesPreference where
  parseJSON :: Value -> Parser FilesPreference
parseJSON Value
v = $(J.mkParseJSON defaultJSON ''FilesPreference) Value
v
  omittedField :: Maybe FilesPreference
omittedField = FilesPreference -> Maybe FilesPreference
forall a. a -> Maybe a
Just FilesPreference {allow :: FeatureAllowed
allow = FeatureAllowed
FAAlways}

$(J.deriveJSON defaultJSON ''CallsPreference)

$(J.deriveToJSON defaultJSON ''SessionsPreference)

instance FromJSON SessionsPreference where
  parseJSON :: Value -> Parser SessionsPreference
parseJSON Value
v = $(J.mkParseJSON defaultJSON ''SessionsPreference) Value
v
  omittedField :: Maybe SessionsPreference
omittedField = SessionsPreference -> Maybe SessionsPreference
forall a. a -> Maybe a
Just SessionsPreference {allow :: FeatureAllowed
allow = FeatureAllowed
FANo}

$(J.deriveJSON (taggedObjectJSON $ dropPrefix "CBC") ''ChatBotCommand)

$(J.deriveJSON defaultJSON ''Preferences)

instance ToField Preferences where
  toField :: Preferences -> SQLData
toField = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Text -> SQLData)
-> (Preferences -> Text) -> Preferences -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Preferences -> Text
forall a. ToJSON a => a -> Text
encodeJSON

instance FromField Preferences where
  fromField :: FieldParser Preferences
fromField = (Text -> Maybe Preferences) -> FieldParser Preferences
forall a. Typeable a => (Text -> Maybe a) -> Field -> Ok a
fromTextField_ Text -> Maybe Preferences
forall a. FromJSON a => Text -> Maybe a
decodeJSON

$(J.deriveJSON defaultJSON ''GroupPreference)

$(J.deriveJSON defaultJSON ''TimedMessagesGroupPreference)

$(J.deriveJSON defaultJSON ''DirectMessagesGroupPreference)

$(J.deriveJSON defaultJSON ''ReactionsGroupPreference)

$(J.deriveJSON defaultJSON ''FullDeleteGroupPreference)

$(J.deriveJSON defaultJSON ''VoiceGroupPreference)

$(J.deriveJSON defaultJSON ''FilesGroupPreference)

$(J.deriveJSON defaultJSON ''SimplexLinksGroupPreference)

$(J.deriveJSON defaultJSON ''ReportsGroupPreference)

$(J.deriveJSON defaultJSON ''HistoryGroupPreference)

$(J.deriveToJSON defaultJSON ''SessionsGroupPreference)

instance FromJSON SessionsGroupPreference where
  parseJSON :: Value -> Parser SessionsGroupPreference
parseJSON Value
v = $(J.mkParseJSON defaultJSON ''SessionsGroupPreference) Value
v
  omittedField :: Maybe SessionsGroupPreference
omittedField = SessionsGroupPreference -> Maybe SessionsGroupPreference
forall a. a -> Maybe a
Just SessionsGroupPreference {enable :: GroupFeatureEnabled
enable = GroupFeatureEnabled
FEOff, role :: Maybe GroupMemberRole
role = Maybe GroupMemberRole
forall a. Maybe a
Nothing}

$(J.deriveJSON defaultJSON ''GroupPreferences)

instance ToField GroupPreferences where
  toField :: GroupPreferences -> SQLData
toField = Text -> SQLData
forall a. ToField a => a -> SQLData
toField (Text -> SQLData)
-> (GroupPreferences -> Text) -> GroupPreferences -> SQLData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GroupPreferences -> Text
forall a. ToJSON a => a -> Text
encodeJSON

instance FromField GroupPreferences where
  fromField :: FieldParser GroupPreferences
fromField = (Text -> Maybe GroupPreferences) -> FieldParser GroupPreferences
forall a. Typeable a => (Text -> Maybe a) -> Field -> Ok a
fromTextField_ Text -> Maybe GroupPreferences
forall a. FromJSON a => Text -> Maybe a
decodeJSON

$(J.deriveJSON defaultJSON ''FullPreferences)

$(J.deriveJSON defaultJSON ''FullGroupPreferences)

$(J.deriveJSON defaultJSON ''PrefEnabled)

instance FromJSON p => FromJSON (ContactUserPref p) where
  parseJSON :: Value -> Parser (ContactUserPref p)
parseJSON = $(J.mkParseJSON (sumTypeJSON $ dropPrefix "CUP") ''ContactUserPref)

instance ToJSON p => ToJSON (ContactUserPref p) where
  toJSON :: ContactUserPref p -> Value
toJSON = $(J.mkToJSON (sumTypeJSON $ dropPrefix "CUP") ''ContactUserPref)
  toEncoding :: ContactUserPref p -> Encoding
toEncoding = $(J.mkToEncoding (sumTypeJSON $ dropPrefix "CUP") ''ContactUserPref)

instance FromJSON p => FromJSON (ContactUserPreference p) where
  parseJSON :: Value -> Parser (ContactUserPreference p)
parseJSON = $(J.mkParseJSON defaultJSON ''ContactUserPreference)

instance ToJSON p => ToJSON (ContactUserPreference p) where
  toJSON :: ContactUserPreference p -> Value
toJSON = $(J.mkToJSON defaultJSON ''ContactUserPreference)
  toEncoding :: ContactUserPreference p -> Encoding
toEncoding = $(J.mkToEncoding defaultJSON ''ContactUserPreference)

$(J.deriveJSON defaultJSON ''ContactUserPreferences)