{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
module Network.WebexTeams.Types where
import GHC.Generics (Generic)
import Data.Aeson (FromJSON, ToJSON (..), parseJSON,
withText)
import Data.Aeson.Encoding (string)
import Data.Aeson.TH (constructorTagModifier,
defaultOptions, deriveJSON,
fieldLabelModifier,
omitNothingFields)
import Data.ByteString (ByteString)
import Data.Default (Default (def))
import Data.Maybe (catMaybes, maybeToList)
import Data.Text (Text)
import Data.Text.Encoding (encodeUtf8)
import Network.WebexTeams.Internal
peoplePath :: ByteString
peoplePath = "people"
roomsPath :: ByteString
roomsPath = "rooms"
membershipsPath :: ByteString
membershipsPath = "memberships"
messagesPath :: ByteString
messagesPath = "messages"
teamsPath :: ByteString
teamsPath = "teams"
teamMembershipsPath :: ByteString
teamMembershipsPath = "team/memberships"
organizationsPath :: ByteString
organizationsPath = "organizations"
licensesPath :: ByteString
licensesPath = "licenses"
rolesPath :: ByteString
rolesPath = "roles"
webhooksPath :: ByteString
webhooksPath = "webhooks"
class FromJSON (ToList i) => WebexTeamsListItem i where
type ToList i :: *
unwrap :: ToList i -> [i]
class WebexTeamsApiPath a where
apiPath :: a -> ByteString
class FromJSON (ToResponse a) => WebexTeamsResponse a where
type ToResponse a :: *
class (WebexTeamsApiPath a, WebexTeamsResponse a) => WebexTeamsDetail a where
toIdStr :: a -> Text
class (WebexTeamsApiPath a, WebexTeamsResponse a) => WebexTeamsFilter a where
toFilterList :: a -> [(ByteString, Maybe ByteString)]
class (WebexTeamsApiPath a, WebexTeamsResponse a, ToJSON a) => WebexTeamsCreate a where
class (WebexTeamsApiPath a, WebexTeamsResponse a, ToJSON a) => WebexTeamsUpdate a where
newtype Timestamp = Timestamp Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype ErrorCode = ErrorCode Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data ErrorTitle = ErrorTitle
{ errorTitleCode :: ErrorCode
, errorTitleReason :: Text
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''ErrorTitle)
newtype Errors = Errors { errorsTitle :: ErrorTitle } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 6, omitNothingFields = True } ''Errors)
newtype PersonId = PersonId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype Email = Email Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype DisplayName = DisplayName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype NickName = NickName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype FirstName = FirstName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype LastName = LastName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype AvatarUrl = AvatarUrl Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype OrganizationId = OrganizationId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype RoleId = RoleId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype LicenseId = LicenseId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype Timezone = Timezone Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data PersonStatus = PersonStatusActive
| PersonStatusInactive
| PersonStatusOutOfOffice
| PersonStatusDoNotDisturb
| PersonStatusUnknown
deriving (Eq, Generic, Show)
instance ToJSON PersonStatus where
toEncoding PersonStatusActive = string "active"
toEncoding PersonStatusInactive = string "inactive"
toEncoding PersonStatusOutOfOffice = string "OutOfOffice"
toEncoding PersonStatusDoNotDisturb = string "DoNotDisturb"
toEncoding PersonStatusUnknown = string "unknown"
instance FromJSON PersonStatus where
parseJSON = withText "Pserson.Status" $ \s -> case s of
"active" -> pure PersonStatusActive
"inactive" -> pure PersonStatusInactive
"OutOfOffice" -> pure PersonStatusOutOfOffice
"DoNotDisturb" -> pure PersonStatusDoNotDisturb
"unknown" -> pure PersonStatusUnknown
_ -> fail "Parsing Person.Status value failed: expected \"active\", \"inactive\", \"OutOfOffice\", \"DoNotDisturb\" or \"unknown\""
data PersonType = PersonTypePerson
| PersonTypeBot
deriving (Eq, Show)
$(deriveJSON defaultOptions { constructorTagModifier = dropAndLow 10 } ''PersonType)
data Person = Person
{ personId :: PersonId
, personErrors :: Maybe Errors
, personEmails :: Maybe [Email]
, personDisplayName :: Maybe DisplayName
, personNickName :: Maybe NickName
, personFirstName :: Maybe FirstName
, personLastName :: Maybe LastName
, personAvatar :: Maybe AvatarUrl
, personOrgId :: Maybe OrganizationId
, personRoles :: Maybe [RoleId]
, personLicenses :: Maybe [LicenseId]
, personCreated :: Maybe Timestamp
, personTimezone :: Maybe Timezone
, personLastActivity :: Maybe Timestamp
, personStatus :: Maybe PersonStatus
, personInvitePending :: Maybe Bool
, personLoginEnabled :: Maybe Bool
, personType :: Maybe PersonType
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 6, omitNothingFields = True } ''Person)
instance WebexTeamsApiPath PersonId where
apiPath _ = peoplePath
instance WebexTeamsResponse PersonId where
type ToResponse PersonId = Person
instance WebexTeamsDetail PersonId where
toIdStr (PersonId s) = s
newtype PersonList = PersonList { personListItems :: [Person] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''PersonList)
instance WebexTeamsListItem Person where
type ToList Person = PersonList
unwrap = personListItems
data PersonFilter = PersonFilter
{ personFilterEmail :: Maybe Email
, personFilterDisplayName :: Maybe DisplayName
, personFilterOrgId :: Maybe OrganizationId
} deriving (Default, Eq, Generic, Show)
instance WebexTeamsApiPath PersonFilter where
apiPath _ = peoplePath
instance WebexTeamsResponse PersonFilter where
type ToResponse PersonFilter = Person
instance WebexTeamsFilter PersonFilter where
toFilterList filter = catMaybes
[ (\(Email e) -> ("email", Just $ encodeUtf8 e)) <$> personFilterEmail filter
, (\(DisplayName n) -> ("displayName", Just (encodeUtf8 n))) <$> personFilterDisplayName filter
, (\(OrganizationId o) -> ("orgId", Just (encodeUtf8 o))) <$> personFilterOrgId filter
]
data CreatePerson = CreatePerson
{ createPersonEmails :: Maybe [Email]
, createPersonDisplayName :: Maybe DisplayName
, createPersonFirstName :: Maybe FirstName
, createPersonLastName :: Maybe LastName
, createPersonAvatar :: Maybe AvatarUrl
, createPersonOrgId :: Maybe OrganizationId
, createPersonRoles :: Maybe [RoleId]
, createPersonLicenses :: Maybe [LicenseId]
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 12, omitNothingFields = True } ''CreatePerson)
instance WebexTeamsApiPath CreatePerson where
apiPath _ = peoplePath
instance WebexTeamsResponse CreatePerson where
type ToResponse CreatePerson = Person
instance WebexTeamsCreate CreatePerson where
data UpdatePerson = UpdatePerson
{ updatePersonDisplayName :: Maybe DisplayName
, updatePersonFirstName :: Maybe FirstName
, updatePersonLastName :: Maybe LastName
, updatePersonAvatar :: Maybe AvatarUrl
, updatePersonOrgId :: Maybe OrganizationId
, updatePersonRoles :: Maybe [RoleId]
, updatePersonLicenses :: Maybe [LicenseId]
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 12, omitNothingFields = True } ''UpdatePerson)
instance WebexTeamsApiPath UpdatePerson where
apiPath _ = peoplePath
instance WebexTeamsResponse UpdatePerson where
type ToResponse UpdatePerson = Person
instance WebexTeamsUpdate UpdatePerson
newtype TeamId = TeamId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype TeamName = TeamName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data Team = Team
{ teamId :: TeamId
, teamErrors :: Maybe Errors
, teamName :: Maybe TeamName
, teamCreatorId :: Maybe PersonId
, teamCreated :: Maybe Timestamp
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 4, omitNothingFields = True } ''Team)
instance WebexTeamsApiPath TeamId where
apiPath _ = teamsPath
instance WebexTeamsResponse TeamId where
type ToResponse TeamId = Team
instance WebexTeamsDetail TeamId where
toIdStr (TeamId s) = s
newtype TeamList = TeamList { teamListItems :: [Team] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 8, omitNothingFields = True } ''TeamList)
instance WebexTeamsListItem Team where
type ToList Team = TeamList
unwrap = teamListItems
newtype CreateTeam = CreateTeam { createTeamName :: TeamName } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''CreateTeam)
instance WebexTeamsApiPath CreateTeam where
apiPath _ = teamsPath
instance WebexTeamsResponse CreateTeam where
type ToResponse CreateTeam = Team
instance WebexTeamsCreate CreateTeam where
newtype UpdateTeam = UpdateTeam { updateTeamName :: TeamName } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''UpdateTeam)
instance WebexTeamsApiPath UpdateTeam where
apiPath _ = teamsPath
instance WebexTeamsResponse UpdateTeam where
type ToResponse UpdateTeam = Team
instance WebexTeamsUpdate UpdateTeam
newtype TeamMembershipId = TeamMembershipId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data TeamMembership = TeamMembership
{ teamMembershipId :: TeamMembershipId
, teamMembershipErrors :: Maybe Errors
, teamMembershipTeamId :: Maybe TeamId
, teamMembershipPersonId :: Maybe PersonId
, teamMembershipPersonEmail :: Maybe Email
, teamMembershipPersonDisplayName :: Maybe DisplayName
, teamMembershipPersonOrgId :: Maybe OrganizationId
, teamMembershipIsModerator :: Maybe Bool
, teamMembershipCreated :: Maybe Timestamp
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 14, omitNothingFields = True } ''TeamMembership)
instance WebexTeamsApiPath TeamMembershipId where
apiPath _ = teamMembershipsPath
instance WebexTeamsResponse TeamMembershipId where
type ToResponse TeamMembershipId = TeamMembership
instance WebexTeamsDetail TeamMembershipId where
toIdStr (TeamMembershipId s) = s
newtype TeamMembershipList = TeamMembershipList { teamMembershipListItems :: [TeamMembership] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 18, omitNothingFields = True } ''TeamMembershipList)
instance WebexTeamsListItem TeamMembership where
type ToList TeamMembership = TeamMembershipList
unwrap = teamMembershipListItems
newtype TeamMembershipFilter = TeamMembershipFilter
{ teamMembershipFilterTeamId :: TeamId
} deriving (Eq, Show)
instance WebexTeamsApiPath TeamMembershipFilter where
apiPath _ = teamMembershipsPath
instance WebexTeamsResponse TeamMembershipFilter where
type ToResponse TeamMembershipFilter = TeamMembership
instance WebexTeamsFilter TeamMembershipFilter where
toFilterList filter = let (TeamId t) = teamMembershipFilterTeamId filter in [("teamId", Just $ encodeUtf8 t)]
defaultTeamMembershipFilter :: TeamId -> TeamMembershipFilter
defaultTeamMembershipFilter = TeamMembershipFilter
data CreateTeamMembership = CreateTeamMembership
{ createTeamMembershipTeamId :: TeamId
, createTeamMembershipPersonId :: Maybe PersonId
, createTeamMembershipPersonEmail :: Maybe Email
, createTeamMembershipIsModerator :: Maybe Bool
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 20, omitNothingFields = True } ''CreateTeamMembership)
instance WebexTeamsApiPath CreateTeamMembership where
apiPath _ = teamMembershipsPath
instance WebexTeamsResponse CreateTeamMembership where
type ToResponse CreateTeamMembership = TeamMembership
instance WebexTeamsCreate CreateTeamMembership where
newtype UpdateTeamMembership = UpdateTeamMembership { updateTeamMembershipIsModerator :: Bool } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 20, omitNothingFields = True } ''UpdateTeamMembership)
instance WebexTeamsApiPath UpdateTeamMembership where
apiPath _ = teamMembershipsPath
instance WebexTeamsResponse UpdateTeamMembership where
type ToResponse UpdateTeamMembership = TeamMembership
instance WebexTeamsUpdate UpdateTeamMembership
newtype RoomId = RoomId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype RoomTitle = RoomTitle Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype SipAddr = SipAddr Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data RoomType = RoomTypeDirect
| RoomTypeGroup
deriving (Eq, Show)
$(deriveJSON defaultOptions { constructorTagModifier = dropAndLow 8 } ''RoomType)
data Room = Room
{ roomId :: RoomId
, roomErrors :: Maybe Errors
, roomTitle :: Maybe RoomTitle
, roomType :: Maybe RoomType
, roomIsLocked :: Maybe Bool
, roomSipAddress :: Maybe SipAddr
, roomLastActivity :: Maybe Timestamp
, roomTeamId :: Maybe TeamId
, roomCreatorId :: Maybe PersonId
, roomCreated :: Maybe Timestamp
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 4, omitNothingFields = True } ''Room)
instance WebexTeamsApiPath RoomId where
apiPath _ = roomsPath
instance WebexTeamsResponse RoomId where
type ToResponse RoomId = Room
instance WebexTeamsDetail RoomId where
toIdStr (RoomId s) = s
newtype RoomList = RoomList { roomListItems :: [Room] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 8, omitNothingFields = True } ''RoomList)
instance WebexTeamsListItem Room where
type ToList Room = RoomList
unwrap = roomListItems
data RoomFilterSortBy = RoomFilterSortById | RoomFilterSortByLastActivity | RoomFilterSortByCreated deriving (Eq, Show)
data RoomFilter = RoomFilter
{ roomFilterTeamId :: Maybe TeamId
, roomFilterRoomType :: Maybe RoomType
, roomFilterSortBy :: Maybe RoomFilterSortBy
} deriving (Default, Eq, Generic, Show)
roomTypeToFilterString :: RoomType -> ByteString
roomTypeToFilterString RoomTypeDirect = "direct"
roomTypeToFilterString RoomTypeGroup = "group"
roomFilterSortByToFilterString :: RoomFilterSortBy -> ByteString
roomFilterSortByToFilterString RoomFilterSortById = "id"
roomFilterSortByToFilterString RoomFilterSortByLastActivity = "lastactivity"
roomFilterSortByToFilterString RoomFilterSortByCreated = "created"
instance WebexTeamsApiPath RoomFilter where
apiPath _ = roomsPath
instance WebexTeamsResponse RoomFilter where
type ToResponse RoomFilter = Room
instance WebexTeamsFilter RoomFilter where
toFilterList filter = catMaybes
[ (\(TeamId e) -> ("teamId", Just $ encodeUtf8 e)) <$> roomFilterTeamId filter
, (\t -> ("type", Just $ roomTypeToFilterString t)) <$> roomFilterRoomType filter
, (\o -> ("sortBy", Just $ roomFilterSortByToFilterString o)) <$> roomFilterSortBy filter
]
data CreateRoom = CreateRoom
{ createRoomTitle :: RoomTitle
, createRoomTeamId :: Maybe TeamId
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''CreateRoom)
instance WebexTeamsApiPath CreateRoom where
apiPath _ = roomsPath
instance WebexTeamsResponse CreateRoom where
type ToResponse CreateRoom = Room
instance WebexTeamsCreate CreateRoom where
newtype UpdateRoom = UpdateRoom { updateRoomTitle :: RoomTitle } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''UpdateRoom)
instance WebexTeamsApiPath UpdateRoom where
apiPath _ = roomsPath
instance WebexTeamsResponse UpdateRoom where
type ToResponse UpdateRoom = Room
instance WebexTeamsUpdate UpdateRoom
newtype MembershipId = MembershipId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data Membership = Membership
{ membershipId :: MembershipId
, membershipErrors :: Maybe Errors
, membershipRoomId :: Maybe RoomId
, membershipPersonId :: Maybe PersonId
, membershipPersonEmail :: Maybe Email
, membershipPersonDisplayName :: Maybe DisplayName
, membershipPersonOrgId :: Maybe OrganizationId
, membershipIsModerator :: Maybe Bool
, membershipIsMonitor :: Maybe Bool
, membershipCreated :: Maybe Timestamp
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''Membership)
instance WebexTeamsApiPath MembershipId where
apiPath _ = membershipsPath
instance WebexTeamsResponse MembershipId where
type ToResponse MembershipId = Membership
instance WebexTeamsDetail MembershipId where
toIdStr (MembershipId s) = s
newtype MembershipList = MembershipList { membershipListItems :: [Membership] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 14, omitNothingFields = True } ''MembershipList)
instance WebexTeamsListItem Membership where
type ToList Membership = MembershipList
unwrap = membershipListItems
data MembershipFilter = MembershipFilter
{ membershipFilterRoomId :: Maybe RoomId
, membershipFilterPersonId :: Maybe PersonId
, membershipFilterPersonEmail :: Maybe Email
} deriving (Default, Eq, Generic, Show)
instance WebexTeamsApiPath MembershipFilter where
apiPath _ = membershipsPath
instance WebexTeamsResponse MembershipFilter where
type ToResponse MembershipFilter = Membership
instance WebexTeamsFilter MembershipFilter where
toFilterList filter = catMaybes
[ (\(RoomId r) -> ("roomId", Just $ encodeUtf8 r)) <$> membershipFilterRoomId filter
, (\(PersonId p) -> ("personId", Just $ encodeUtf8 p)) <$> membershipFilterPersonId filter
, (\(Email e) -> ("personEmail", Just $ encodeUtf8 e)) <$> membershipFilterPersonEmail filter
]
data CreateMembership = CreateMembership
{ createMembershipRoomId :: RoomId
, createMembershipPersonId :: Maybe PersonId
, createMembershipPersonEmail :: Maybe Email
, createMembershipIsModerator :: Maybe Bool
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 16, omitNothingFields = True } ''CreateMembership)
instance WebexTeamsApiPath CreateMembership where
apiPath _ = membershipsPath
instance WebexTeamsResponse CreateMembership where
type ToResponse CreateMembership = Membership
instance WebexTeamsCreate CreateMembership where
newtype UpdateMembership = UpdateMembership { updateMembershipIsModerator :: Bool } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 16, omitNothingFields = True } ''UpdateMembership)
instance WebexTeamsApiPath UpdateMembership where
apiPath _ = membershipsPath
instance WebexTeamsResponse UpdateMembership where
type ToResponse UpdateMembership = Membership
instance WebexTeamsUpdate UpdateMembership
newtype MessageId = MessageId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype MessageText = MessageText Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype MessageHtml = MessageHtml Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype MessageMarkdown = MessageMarkdown Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype FileUrl = FileUrl Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data Message = Message
{ messageId :: MessageId
, messageErrors :: Maybe Errors
, messageRoomId :: Maybe RoomId
, messageRoomType :: Maybe RoomType
, messageToPersonId :: Maybe PersonId
, messageToPersonEmail :: Maybe Email
, messageText :: Maybe MessageText
, messageHtml :: Maybe MessageHtml
, messageFiles :: Maybe [FileUrl]
, messagePersonId :: Maybe PersonId
, messagePersonEmail :: Maybe Email
, messageCreated :: Maybe Timestamp
, messageMentionedPeople :: Maybe [PersonId]
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 7, omitNothingFields = True } ''Message)
instance WebexTeamsApiPath MessageId where
apiPath _ = messagesPath
instance WebexTeamsResponse MessageId where
type ToResponse MessageId = Message
instance WebexTeamsDetail MessageId where
toIdStr (MessageId s) = s
newtype MessageList = MessageList { messageListItems :: [Message] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 11, omitNothingFields = True } ''MessageList)
instance WebexTeamsListItem Message where
type ToList Message = MessageList
unwrap = messageListItems
data MentionedPeople = MentionedPeopleMe | MentionedPeople PersonId deriving (Eq, Show)
data MessageFilter = MessageFilter
{ messageFilterRoomId :: RoomId
, messageFilterMentionedPeople :: Maybe MentionedPeople
, messageFilterBefore :: Maybe Timestamp
, messageFilterBeforeMessage :: Maybe MessageId
} deriving (Eq, Show)
defaultMessageFilter :: RoomId -> MessageFilter
defaultMessageFilter roomId = MessageFilter roomId Nothing Nothing Nothing
mentionedPeopleToFilterString :: MentionedPeople -> ByteString
mentionedPeopleToFilterString MentionedPeopleMe = "me"
mentionedPeopleToFilterString (MentionedPeople (PersonId personId)) = encodeUtf8 personId
instance WebexTeamsApiPath MessageFilter where
apiPath _ = messagesPath
instance WebexTeamsResponse MessageFilter where
type ToResponse MessageFilter = Message
instance WebexTeamsFilter MessageFilter where
toFilterList filter = ("roomId", Just $ encodeUtf8 rid) : catMaybes
[ (\p -> ("mentionedPeople", Just $ mentionedPeopleToFilterString p)) <$> messageFilterMentionedPeople filter
, (\(Timestamp t) -> ("before", Just $ encodeUtf8 t)) <$> messageFilterBefore filter
, (\(MessageId m) -> ("beforeMessage", Just $ encodeUtf8 m)) <$> messageFilterBeforeMessage filter
]
where
(RoomId rid) = messageFilterRoomId filter
data CreateMessage = CreateMessage
{ createMessageRoomId :: Maybe RoomId
, createMessageToPersonId :: Maybe PersonId
, createMessageToPersonEmail :: Maybe Email
, createMessageText :: Maybe MessageText
, createMessageMarkdown :: Maybe MessageMarkdown
, createMessageFiles :: Maybe [FileUrl]
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 13, omitNothingFields = True } ''CreateMessage)
instance WebexTeamsApiPath CreateMessage where
apiPath _ = messagesPath
instance WebexTeamsResponse CreateMessage where
type ToResponse CreateMessage = Message
instance WebexTeamsCreate CreateMessage where
newtype OrganizationDisplayName = OrganizationDisplayName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data Organization = Organization
{ organizationId :: OrganizationId
, organizationErrors :: Maybe Errors
, organizationDisplayName :: Maybe OrganizationDisplayName
, organizationCreated :: Maybe Timestamp
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 12, omitNothingFields = True } ''Organization)
instance WebexTeamsApiPath OrganizationId where
apiPath _ = organizationsPath
instance WebexTeamsResponse OrganizationId where
type ToResponse OrganizationId = Organization
instance WebexTeamsDetail OrganizationId where
toIdStr (OrganizationId s) = s
newtype OrganizationList = OrganizationList { organizationListItems :: [Organization] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 16, omitNothingFields = True } ''OrganizationList)
instance WebexTeamsListItem Organization where
type ToList Organization = OrganizationList
unwrap = organizationListItems
newtype LicenseName = LicenseName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype LicenseUnit = LicenseUnit Integer deriving (Eq, Show, Generic, ToJSON, FromJSON)
data License = License
{ licenseId :: LicenseId
, licenseErrors :: Maybe Errors
, licenseName :: Maybe LicenseName
, licenseTotalUnits :: Maybe LicenseUnit
, licenseConsumedUnits :: Maybe LicenseUnit
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 7, omitNothingFields = True } ''License)
instance WebexTeamsApiPath LicenseId where
apiPath _ = licensesPath
instance WebexTeamsResponse LicenseId where
type ToResponse LicenseId = License
instance WebexTeamsDetail LicenseId where
toIdStr (LicenseId s) = s
newtype LicenseList = LicenseList { licenseListItems :: [License] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 11, omitNothingFields = True } ''LicenseList)
instance WebexTeamsListItem License where
type ToList License = LicenseList
unwrap = licenseListItems
newtype LicenseFilter = LicenseFilter
{ licenseFilterOrgId :: Maybe OrganizationId
} deriving (Default, Eq, Generic, Show)
instance WebexTeamsApiPath LicenseFilter where
apiPath _ = licensesPath
instance WebexTeamsResponse LicenseFilter where
type ToResponse LicenseFilter = License
instance WebexTeamsFilter LicenseFilter where
toFilterList filter = maybeToList $ (\(OrganizationId o) -> ("orgId", Just $ encodeUtf8 o)) <$> licenseFilterOrgId filter
newtype RoleName = RoleName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data Role = Role
{ roleId :: RoleId
, roleErrors :: Maybe Errors
, roleName :: Maybe RoleName
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 4, omitNothingFields = True } ''Role)
instance WebexTeamsApiPath RoleId where
apiPath _ = rolesPath
instance WebexTeamsResponse RoleId where
type ToResponse RoleId = Role
instance WebexTeamsDetail RoleId where
toIdStr (RoleId s) = s
newtype RoleList = RoleList { roleListItems :: [Role] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 8, omitNothingFields = True } ''RoleList)
instance WebexTeamsListItem Role where
type ToList Role = RoleList
unwrap = roleListItems
newtype WebhookId = WebhookId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype WebhookName = WebhookName Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype WebhookUrl = WebhookUrl Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype WebhookFilter = WebhookFilter Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
newtype WebhookSecret = WebhookSecret Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data WebhookResource = WebhookResourceAll
| WebhookResourceTeams
| WebhookResourceMemberships
| WebhookResourceMessages
| WebhookResourceRooms
deriving (Eq, Show)
$(deriveJSON defaultOptions { constructorTagModifier = dropAndLow 15 } ''WebhookResource)
data WebhookEvent = WebhookEventAll
| WebhookEventCreated
| WebhookEventUpdated
| WebhookEventDeleted
deriving (Eq, Show)
$(deriveJSON defaultOptions { constructorTagModifier = dropAndLow 12 } ''WebhookEvent)
data Webhook = Webhook
{ webhookId :: WebhookId
, webhookErrors :: Maybe Errors
, webhookName :: Maybe WebhookName
, webhookTargetUrl :: Maybe WebhookUrl
, webhookResource :: Maybe WebhookResource
, webhookEvent :: Maybe WebhookEvent
, webhookFilter :: Maybe WebhookFilter
, webhookSecret :: Maybe WebhookSecret
, webhookCreated :: Maybe Timestamp
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 7, omitNothingFields = True } ''Webhook)
instance WebexTeamsApiPath WebhookId where
apiPath _ = webhooksPath
instance WebexTeamsResponse WebhookId where
type ToResponse WebhookId = Webhook
instance WebexTeamsDetail WebhookId where
toIdStr (WebhookId s) = s
newtype WebhookList = WebhookList { webhookListItems :: [Webhook] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 11, omitNothingFields = True } ''WebhookList)
instance WebexTeamsListItem Webhook where
type ToList Webhook = WebhookList
unwrap = webhookListItems
data CreateWebhook = CreateWebhook
{ createWebhookName :: WebhookName
, createWebhookTargetUrl :: WebhookUrl
, createWebhookResource :: WebhookResource
, createWebhookEvent :: WebhookEvent
, createWebhookFilter :: Maybe WebhookFilter
, createWebhookSecret :: Maybe WebhookSecret
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 13, omitNothingFields = True } ''CreateWebhook)
instance WebexTeamsApiPath CreateWebhook where
apiPath _ = webhooksPath
instance WebexTeamsResponse CreateWebhook where
type ToResponse CreateWebhook = Webhook
instance WebexTeamsCreate CreateWebhook where
data UpdateWebhook = UpdateWebhook
{ updateWebhookName :: WebhookName
, updateWebhookTargetUrl :: WebhookUrl
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 13, omitNothingFields = True } ''UpdateWebhook)
instance WebexTeamsApiPath UpdateWebhook where
apiPath _ = webhooksPath
instance WebexTeamsResponse UpdateWebhook where
type ToResponse UpdateWebhook = Webhook
instance WebexTeamsUpdate UpdateWebhook
data WebhookMembershipFilter = WebhookMembershipFilter
{ webhookFilterMembershipRoomId :: Maybe RoomId
, webhookFilterMembershipPersonId :: Maybe PersonId
, webhookFilterMembershipPersonEmail :: Maybe Email
, webhookFilterMembershipIsModerator :: Maybe Bool
} deriving (Eq, Show)
instance WebexTeamsApiPath WebhookMembershipFilter where
apiPath _ = webhooksPath
instance WebexTeamsResponse WebhookMembershipFilter where
type ToResponse WebhookMembershipFilter = Webhook
instance WebexTeamsFilter WebhookMembershipFilter where
toFilterList filter = catMaybes
[ (\(RoomId r) -> ("roomId", Just $ encodeUtf8 r)) <$> webhookFilterMembershipRoomId filter
, (\(PersonId p) -> ("personId", Just (encodeUtf8 p))) <$> webhookFilterMembershipPersonId filter
, (\(Email e) -> ("personEmail", Just (encodeUtf8 e))) <$> webhookFilterMembershipPersonEmail filter
, (\b -> ("isModerator", Just (if b then "true" else "false"))) <$> webhookFilterMembershipIsModerator filter
]
data WebhookMessageFilter = WebhookMessageFilter
{ webhookFilterMessageRoomId :: Maybe RoomId
, webhookFilterMessageRoomType :: Maybe RoomType
, webhookFilterMessagePersonId :: Maybe PersonId
, webhookFilterMessagePersonEmail :: Maybe Email
, webhookFilterMessagememtionedPeople :: Maybe MentionedPeople
, webhookFilterMessageHasFiles :: Maybe Bool
} deriving (Eq, Show)
instance WebexTeamsApiPath WebhookMessageFilter where
apiPath _ = webhooksPath
instance WebexTeamsResponse WebhookMessageFilter where
type ToResponse WebhookMessageFilter = Webhook
instance WebexTeamsFilter WebhookMessageFilter where
toFilterList filter = catMaybes
[ (\(RoomId r) -> ("roomId", Just $ encodeUtf8 r)) <$> webhookFilterMessageRoomId filter
, (\t -> ("roomType", Just $ roomTypeToFilterString t)) <$> webhookFilterMessageRoomType filter
, (\(PersonId p) -> ("personId", Just (encodeUtf8 p))) <$> webhookFilterMessagePersonId filter
, (\(Email e) -> ("personEmail", Just (encodeUtf8 e))) <$> webhookFilterMessagePersonEmail filter
, (\p -> ("mentionedPeople", Just $ mentionedPeopleToFilterString p)) <$> webhookFilterMessagememtionedPeople filter
, (\b -> ("hasFiles", Just (if b then "true" else "false"))) <$> webhookFilterMessageHasFiles filter
]
data WebhookRoomFilter = WebhookRoomFilter
{ webhookFilterRoomType :: Maybe RoomType
, webhookFilterRoomIsLocked :: Maybe Bool
} deriving (Eq, Show)
instance WebexTeamsApiPath WebhookRoomFilter where
apiPath _ = webhooksPath
instance WebexTeamsResponse WebhookRoomFilter where
type ToResponse WebhookRoomFilter = Webhook
instance WebexTeamsFilter WebhookRoomFilter where
toFilterList filter = catMaybes
[ (\t -> ("type", Just $ roomTypeToFilterString t)) <$> webhookFilterRoomType filter
, (\b -> ("isLocked", Just (if b then "true" else "false"))) <$> webhookFilterRoomIsLocked filter
]
newtype AppId = AppId Text deriving (Eq, Show, Generic, ToJSON, FromJSON)
data WebhookNotifyOwnedBy = WebhookNotifyOwnedByOrg | WebhookNotifyOwnedByCreator deriving (Eq, Show)
$(deriveJSON defaultOptions { constructorTagModifier = dropAndLow 18 } ''WebhookNotifyOwnedBy)
data WebhookNotifyStatus = WebhookNotifyStatusActive | WebhookNotifyStatusDesabled deriving (Eq, Show)
$(deriveJSON defaultOptions { constructorTagModifier = dropAndLow 19 } ''WebhookNotifyStatus)
data WebhookNotify = WebhookNotify
{ webhookNotifyId :: WebhookId
, webhookNotifyName :: WebhookName
, webhookNotifyResource :: WebhookResource
, webhookNotifyEvent :: WebhookEvent
, webhookNotifyFilter :: WebhookFilter
, webhookNotifyOrgId :: Organization
, webhookNotifyCreatedBy :: PersonId
, webhookNotifyAppId :: AppId
, webhookNotifyOwnedBy :: WebhookNotifyOwnedBy
, webhookNotifyStatus :: WebhookNotifyStatus
, webhookNotifyActorId :: PersonId
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 13, omitNothingFields = True } ''WebhookNotify)
newtype WebhookNotifyMembership = WebhookNotifyMembership { webhookNotifyMembershipData :: Membership } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 23, omitNothingFields = True } ''WebhookNotifyMembership)
newtype WebhookNotifyMessage = WebhookNotifyMessage { webhookNotifyMessageData :: Message } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 20, omitNothingFields = True } ''WebhookNotifyMessage)
newtype WebhookNotifyRoom = WebhookNotifyRoom { webhookNotifyRoomData :: Room } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 17, omitNothingFields = True } ''WebhookNotifyRoom)