1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
module Aws.SimpleDb.Commands.Domain where
import Aws.Core
import Aws.SimpleDb.Core
import Control.Applicative
import Data.Maybe
import Data.Time
import Data.Time.Clock.POSIX
import Prelude
import Text.XML.Cursor (($//), (&|))
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
data CreateDomain
= CreateDomain {
cdDomainName :: T.Text
}
deriving (Show)
data CreateDomainResponse
= CreateDomainResponse
deriving (Show)
createDomain :: T.Text -> CreateDomain
createDomain name = CreateDomain { cdDomainName = name }
-- | ServiceConfiguration: 'SdbConfiguration'
instance SignQuery CreateDomain where
type ServiceConfiguration CreateDomain = SdbConfiguration
signQuery CreateDomain{..} = sdbSignQuery [("Action", "CreateDomain"), ("DomainName", T.encodeUtf8 cdDomainName)]
instance ResponseConsumer r CreateDomainResponse where
type ResponseMetadata CreateDomainResponse = SdbMetadata
responseConsumer _ _
= sdbResponseConsumer $ sdbCheckResponseType CreateDomainResponse "CreateDomainResponse"
instance Transaction CreateDomain CreateDomainResponse
instance AsMemoryResponse CreateDomainResponse where
type MemoryResponse CreateDomainResponse = CreateDomainResponse
loadToMemory = return
data DeleteDomain
= DeleteDomain {
ddDomainName :: T.Text
}
deriving (Show)
data DeleteDomainResponse
= DeleteDomainResponse
deriving (Show)
deleteDomain :: T.Text -> DeleteDomain
deleteDomain name = DeleteDomain { ddDomainName = name }
-- | ServiceConfiguration: 'SdbConfiguration'
instance SignQuery DeleteDomain where
type ServiceConfiguration DeleteDomain = SdbConfiguration
signQuery DeleteDomain{..} = sdbSignQuery [("Action", "DeleteDomain"), ("DomainName", T.encodeUtf8 ddDomainName)]
instance ResponseConsumer r DeleteDomainResponse where
type ResponseMetadata DeleteDomainResponse = SdbMetadata
responseConsumer _ _
= sdbResponseConsumer $ sdbCheckResponseType DeleteDomainResponse "DeleteDomainResponse"
instance Transaction DeleteDomain DeleteDomainResponse
instance AsMemoryResponse DeleteDomainResponse where
type MemoryResponse DeleteDomainResponse = DeleteDomainResponse
loadToMemory = return
data DomainMetadata
= DomainMetadata {
dmDomainName :: T.Text
}
deriving (Show)
data DomainMetadataResponse
= DomainMetadataResponse {
dmrTimestamp :: UTCTime
, dmrItemCount :: Integer
, dmrAttributeValueCount :: Integer
, dmrAttributeNameCount :: Integer
, dmrItemNamesSizeBytes :: Integer
, dmrAttributeValuesSizeBytes :: Integer
, dmrAttributeNamesSizeBytes :: Integer
}
deriving (Show)
domainMetadata :: T.Text -> DomainMetadata
domainMetadata name = DomainMetadata { dmDomainName = name }
-- | ServiceConfiguration: 'SdbConfiguration'
instance SignQuery DomainMetadata where
type ServiceConfiguration DomainMetadata = SdbConfiguration
signQuery DomainMetadata{..} = sdbSignQuery [("Action", "DomainMetadata"), ("DomainName", T.encodeUtf8 dmDomainName)]
instance ResponseConsumer r DomainMetadataResponse where
type ResponseMetadata DomainMetadataResponse = SdbMetadata
responseConsumer _ _
= sdbResponseConsumer parse
where parse cursor = do
sdbCheckResponseType () "DomainMetadataResponse" cursor
dmrTimestamp <- forceM "Timestamp expected" $ cursor $// elCont "Timestamp" &| (fmap posixSecondsToUTCTime . readInt)
dmrItemCount <- forceM "ItemCount expected" $ cursor $// elCont "ItemCount" &| readInt
dmrAttributeValueCount <- forceM "AttributeValueCount expected" $ cursor $// elCont "AttributeValueCount" &| readInt
dmrAttributeNameCount <- forceM "AttributeNameCount expected" $ cursor $// elCont "AttributeNameCount" &| readInt
dmrItemNamesSizeBytes <- forceM "ItemNamesSizeBytes expected" $ cursor $// elCont "ItemNamesSizeBytes" &| readInt
dmrAttributeValuesSizeBytes <- forceM "AttributeValuesSizeBytes expected" $ cursor $// elCont "AttributeValuesSizeBytes" &| readInt
dmrAttributeNamesSizeBytes <- forceM "AttributeNamesSizeBytes expected" $ cursor $// elCont "AttributeNamesSizeBytes" &| readInt
return DomainMetadataResponse{..}
instance Transaction DomainMetadata DomainMetadataResponse
instance AsMemoryResponse DomainMetadataResponse where
type MemoryResponse DomainMetadataResponse = DomainMetadataResponse
loadToMemory = return
data ListDomains
= ListDomains {
ldMaxNumberOfDomains :: Maybe Int
, ldNextToken :: Maybe T.Text
}
deriving (Show)
data ListDomainsResponse
= ListDomainsResponse {
ldrDomainNames :: [T.Text]
, ldrNextToken :: Maybe T.Text
}
deriving (Show)
listDomains :: ListDomains
listDomains = ListDomains { ldMaxNumberOfDomains = Nothing, ldNextToken = Nothing }
-- | ServiceConfiguration: 'SdbConfiguration'
instance SignQuery ListDomains where
type ServiceConfiguration ListDomains = SdbConfiguration
signQuery ListDomains{..} = sdbSignQuery $ catMaybes [
Just ("Action", "ListDomains")
, ("MaxNumberOfDomains",) . T.encodeUtf8 . T.pack . show <$> ldMaxNumberOfDomains
, ("NextToken",) . T.encodeUtf8 <$> ldNextToken
]
instance ResponseConsumer r ListDomainsResponse where
type ResponseMetadata ListDomainsResponse = SdbMetadata
responseConsumer _ _ = sdbResponseConsumer parse
where parse cursor = do
sdbCheckResponseType () "ListDomainsResponse" cursor
let names = cursor $// elContent "DomainName"
let nextToken = listToMaybe $ cursor $// elContent "NextToken"
return $ ListDomainsResponse names nextToken
instance Transaction ListDomains ListDomainsResponse
instance AsMemoryResponse ListDomainsResponse where
type MemoryResponse ListDomainsResponse = ListDomainsResponse
loadToMemory = return
instance ListResponse ListDomainsResponse T.Text where
listResponse = ldrDomainNames
instance IteratedTransaction ListDomains ListDomainsResponse where
nextIteratedRequest req ListDomainsResponse{ldrNextToken=nt} = req{ldNextToken=nt} <$ nt
--combineIteratedResponse (ListDomainsResponse dn1 _) (ListDomainsResponse dn2 nt2) = ListDomainsResponse (dn1 ++ dn2) nt2
|
