module Network.CiscoSpark.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.CiscoSpark.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) => SparkListItem i where
type ToList i :: *
unwrap :: ToList i -> [i]
class SparkApiPath a where
apiPath :: a -> ByteString
class FromJSON (ToResponse a) => SparkResponse a where
type ToResponse a :: *
class (SparkApiPath a, SparkResponse a) => SparkDetail a where
toIdStr :: a -> Text
class (SparkApiPath a, SparkResponse a) => SparkFilter a where
toFilterList :: a -> [(ByteString, Maybe ByteString)]
class (SparkApiPath a, SparkResponse a, ToJSON a) => SparkCreate a where
class (SparkApiPath a, SparkResponse a, ToJSON a) => SparkUpdate 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 SparkApiPath PersonId where
apiPath _ = peoplePath
instance SparkResponse PersonId where
type ToResponse PersonId = Person
instance SparkDetail PersonId where
toIdStr (PersonId s) = s
newtype PersonList = PersonList { personListItems :: [Person] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''PersonList)
instance SparkListItem 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 SparkApiPath PersonFilter where
apiPath _ = peoplePath
instance SparkResponse PersonFilter where
type ToResponse PersonFilter = Person
instance SparkFilter 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 SparkApiPath CreatePerson where
apiPath _ = peoplePath
instance SparkResponse CreatePerson where
type ToResponse CreatePerson = Person
instance SparkCreate 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 SparkApiPath UpdatePerson where
apiPath _ = peoplePath
instance SparkResponse UpdatePerson where
type ToResponse UpdatePerson = Person
instance SparkUpdate 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 SparkApiPath TeamId where
apiPath _ = teamsPath
instance SparkResponse TeamId where
type ToResponse TeamId = Team
instance SparkDetail TeamId where
toIdStr (TeamId s) = s
newtype TeamList = TeamList { teamListItems :: [Team] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 8, omitNothingFields = True } ''TeamList)
instance SparkListItem 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 SparkApiPath CreateTeam where
apiPath _ = teamsPath
instance SparkResponse CreateTeam where
type ToResponse CreateTeam = Team
instance SparkCreate CreateTeam where
newtype UpdateTeam = UpdateTeam { updateTeamName :: TeamName } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''UpdateTeam)
instance SparkApiPath UpdateTeam where
apiPath _ = teamsPath
instance SparkResponse UpdateTeam where
type ToResponse UpdateTeam = Team
instance SparkUpdate 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 SparkApiPath TeamMembershipId where
apiPath _ = teamMembershipsPath
instance SparkResponse TeamMembershipId where
type ToResponse TeamMembershipId = TeamMembership
instance SparkDetail TeamMembershipId where
toIdStr (TeamMembershipId s) = s
newtype TeamMembershipList = TeamMembershipList { teamMembershipListItems :: [TeamMembership] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 18, omitNothingFields = True } ''TeamMembershipList)
instance SparkListItem TeamMembership where
type ToList TeamMembership = TeamMembershipList
unwrap = teamMembershipListItems
newtype TeamMembershipFilter = TeamMembershipFilter
{ teamMembershipFilterTeamId :: TeamId
} deriving (Eq, Show)
instance SparkApiPath TeamMembershipFilter where
apiPath _ = teamMembershipsPath
instance SparkResponse TeamMembershipFilter where
type ToResponse TeamMembershipFilter = TeamMembership
instance SparkFilter TeamMembershipFilter where
toFilterList filter = let (TeamId t) = teamMembershipFilterTeamId filter in [("teamId", Just $ encodeUtf8 t)]
defaultTeamMembershipFilter :: TeamId -> TeamMembershipFilter
defaultTeamMembershipFilter teamId = TeamMembershipFilter teamId
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 SparkApiPath CreateTeamMembership where
apiPath _ = teamMembershipsPath
instance SparkResponse CreateTeamMembership where
type ToResponse CreateTeamMembership = TeamMembership
instance SparkCreate CreateTeamMembership where
newtype UpdateTeamMembership = UpdateTeamMembership { updateTeamMembershipIsModerator :: Bool } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 20, omitNothingFields = True } ''UpdateTeamMembership)
instance SparkApiPath UpdateTeamMembership where
apiPath _ = teamMembershipsPath
instance SparkResponse UpdateTeamMembership where
type ToResponse UpdateTeamMembership = TeamMembership
instance SparkUpdate 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 SparkApiPath RoomId where
apiPath _ = roomsPath
instance SparkResponse RoomId where
type ToResponse RoomId = Room
instance SparkDetail RoomId where
toIdStr (RoomId s) = s
newtype RoomList = RoomList { roomListItems :: [Room] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 8, omitNothingFields = True } ''RoomList)
instance SparkListItem 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 SparkApiPath RoomFilter where
apiPath _ = roomsPath
instance SparkResponse RoomFilter where
type ToResponse RoomFilter = Room
instance SparkFilter 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 SparkApiPath CreateRoom where
apiPath _ = roomsPath
instance SparkResponse CreateRoom where
type ToResponse CreateRoom = Room
instance SparkCreate CreateRoom where
newtype UpdateRoom = UpdateRoom { updateRoomTitle :: RoomTitle } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 10, omitNothingFields = True } ''UpdateRoom)
instance SparkApiPath UpdateRoom where
apiPath _ = roomsPath
instance SparkResponse UpdateRoom where
type ToResponse UpdateRoom = Room
instance SparkUpdate 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 SparkApiPath MembershipId where
apiPath _ = membershipsPath
instance SparkResponse MembershipId where
type ToResponse MembershipId = Membership
instance SparkDetail MembershipId where
toIdStr (MembershipId s) = s
newtype MembershipList = MembershipList { membershipListItems :: [Membership] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 14, omitNothingFields = True } ''MembershipList)
instance SparkListItem 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 SparkApiPath MembershipFilter where
apiPath _ = membershipsPath
instance SparkResponse MembershipFilter where
type ToResponse MembershipFilter = Membership
instance SparkFilter 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 SparkApiPath CreateMembership where
apiPath _ = membershipsPath
instance SparkResponse CreateMembership where
type ToResponse CreateMembership = Membership
instance SparkCreate CreateMembership where
newtype UpdateMembership = UpdateMembership { updateMembershipIsModerator :: Bool } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 16, omitNothingFields = True } ''UpdateMembership)
instance SparkApiPath UpdateMembership where
apiPath _ = membershipsPath
instance SparkResponse UpdateMembership where
type ToResponse UpdateMembership = Membership
instance SparkUpdate 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 SparkApiPath MessageId where
apiPath _ = messagesPath
instance SparkResponse MessageId where
type ToResponse MessageId = Message
instance SparkDetail MessageId where
toIdStr (MessageId s) = s
newtype MessageList = MessageList { messageListItems :: [Message] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 11, omitNothingFields = True } ''MessageList)
instance SparkListItem 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 SparkApiPath MessageFilter where
apiPath _ = messagesPath
instance SparkResponse MessageFilter where
type ToResponse MessageFilter = Message
instance SparkFilter 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 SparkApiPath CreateMessage where
apiPath _ = messagesPath
instance SparkResponse CreateMessage where
type ToResponse CreateMessage = Message
instance SparkCreate 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 SparkApiPath OrganizationId where
apiPath _ = organizationsPath
instance SparkResponse OrganizationId where
type ToResponse OrganizationId = Organization
instance SparkDetail OrganizationId where
toIdStr (OrganizationId s) = s
newtype OrganizationList = OrganizationList { organizationListItems :: [Organization] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 16, omitNothingFields = True } ''OrganizationList)
instance SparkListItem 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 SparkApiPath LicenseId where
apiPath _ = licensesPath
instance SparkResponse LicenseId where
type ToResponse LicenseId = License
instance SparkDetail LicenseId where
toIdStr (LicenseId s) = s
newtype LicenseList = LicenseList { licenseListItems :: [License] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 11, omitNothingFields = True } ''LicenseList)
instance SparkListItem License where
type ToList License = LicenseList
unwrap = licenseListItems
newtype LicenseFilter = LicenseFilter
{ licenseFilterOrgId :: Maybe OrganizationId
} deriving (Default, Eq, Generic, Show)
instance SparkApiPath LicenseFilter where
apiPath _ = licensesPath
instance SparkResponse LicenseFilter where
type ToResponse LicenseFilter = License
instance SparkFilter 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 SparkApiPath RoleId where
apiPath _ = rolesPath
instance SparkResponse RoleId where
type ToResponse RoleId = Role
instance SparkDetail RoleId where
toIdStr (RoleId s) = s
newtype RoleList = RoleList { roleListItems :: [Role] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 8, omitNothingFields = True } ''RoleList)
instance SparkListItem 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 SparkApiPath WebhookId where
apiPath _ = webhooksPath
instance SparkResponse WebhookId where
type ToResponse WebhookId = Webhook
instance SparkDetail WebhookId where
toIdStr (WebhookId s) = s
newtype WebhookList = WebhookList { webhookListItems :: [Webhook] } deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 11, omitNothingFields = True } ''WebhookList)
instance SparkListItem 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 SparkApiPath CreateWebhook where
apiPath _ = webhooksPath
instance SparkResponse CreateWebhook where
type ToResponse CreateWebhook = Webhook
instance SparkCreate CreateWebhook where
data UpdateWebhook = UpdateWebhook
{ updateWebhookName :: WebhookName
, updateWebhookTargetUrl :: WebhookUrl
} deriving (Eq, Show)
$(deriveJSON defaultOptions { fieldLabelModifier = dropAndLow 13, omitNothingFields = True } ''UpdateWebhook)
instance SparkApiPath UpdateWebhook where
apiPath _ = webhooksPath
instance SparkResponse UpdateWebhook where
type ToResponse UpdateWebhook = Webhook
instance SparkUpdate UpdateWebhook
data WebhookMembershipFilter = WebhookMembershipFilter
{ webhookFilterMembershipRoomId :: Maybe RoomId
, webhookFilterMembershipPersonId :: Maybe PersonId
, webhookFilterMembershipPersonEmail :: Maybe Email
, webhookFilterMembershipIsModerator :: Maybe Bool
} deriving (Eq, Show)
instance SparkApiPath WebhookMembershipFilter where
apiPath _ = webhooksPath
instance SparkResponse WebhookMembershipFilter where
type ToResponse WebhookMembershipFilter = Webhook
instance SparkFilter 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 SparkApiPath WebhookMessageFilter where
apiPath _ = webhooksPath
instance SparkResponse WebhookMessageFilter where
type ToResponse WebhookMessageFilter = Webhook
instance SparkFilter 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 SparkApiPath WebhookRoomFilter where
apiPath _ = webhooksPath
instance SparkResponse WebhookRoomFilter where
type ToResponse WebhookRoomFilter = Webhook
instance SparkFilter 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)