← Back to branch summary

~didrocks/unity/altf10

« back to all changes in this revision

Viewing changes to grackle/client.py

  • Committer: Curtis Hovey
  • Date: 2012-01-31 05:24:10 UTC
  • mfrom: (35.1.19 client-get-messages-0)
  • Revision ID: curtis.hovey@canonical.com-20120131052410-4n5iva4ujik6nhp8
Added support for display_type.
Introduced make_message and make_mime_message to make test data consistent for
InMemoryStore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
grackle/client.py
6
6
    urlencode,
7
7
)
8
8
 
9
 
from grackle.error import (
10
 
    MessageIdNotFound,
11
 
    UnparsableDateRange,
12
 
    UnsupportedDisplayType,
13
 
    UnsupportedOrder,
 
9
 
 
10
class UnsupportedDisplayType(Exception):
 
11
    """Raised when an Unsupported display_type is requested."""
 
12
 
 
13
 
 
14
class UnsupportedOrder(Exception):
 
15
    """Raised when an Unsupported order is requested."""
 
16
 
 
17
 
 
18
SUPPORTED_DISPLAY_TYPES = (
 
19
    'all',
 
20
    'text-only',
 
21
    'headers-only',
14
22
    )
15
23
 
16
24
 
47
55
        connection.request(method, url, body)
48
56
        return connection.getresponse()
49
57
 
50
 
    def put_archive(self, archive_id, mbox=None):
51
 
        """Create an archive.
52
 
 
53
 
        :param archive_id: The archive id.
54
 
        :param mbox: An optional mbox with messages to add to the new archive.
55
 
        """
56
 
        response = self._method_archive(
57
 
            'POST', '', {'archive_id': archive_id}, None)
58
 
        response.read()
59
 
        if response.status == httplib.BAD_REQUEST:
60
 
            raise Exception('wtf')
61
 
        elif response.status == httplib.CREATED:
62
 
            return
63
 
        else:
64
 
            raise Exception('!!')
65
 
 
66
58
    def put_message(self, archive_id, key, file_obj):
67
59
        """Put a message into an archive.
68
60
 
71
63
            the message.
72
64
        :param file_obj: The raw text of the message, as a file.
73
65
        """
74
 
        path = '%s/%s' % (archive_id, key)
75
66
        response = self._method_archive(
76
 
            'POST', path, {}, file_obj.read())
 
67
            'POST', archive_id, {'key': key}, file_obj.read())
77
68
        response.read()
78
69
        if response.status == httplib.BAD_REQUEST:
79
70
            raise Exception('wtf')
82
73
        else:
83
74
            raise Exception('!!')
84
75
 
85
 
    def get_messages(self, archive_id, message_ids=None, date_range=None,
86
 
                     limit=None, memo=None, order=None, headers=None,
87
 
                     include_hidden=False, max_body_length=None,
 
76
    def get_messages(self, archive_id, message_ids=None, limit=None,
 
77
                     memo=None, order=None, headers=None,
 
78
                     max_body_length=None, include_hidden=False,
88
79
                     display_type='all'):
89
80
        """Retrieve specified messages.
90
81
 
91
82
        :param archive_id: The archive to retrieve messages from.
92
83
        :param message_ids: (optional) Retrieve only messages with these ids.
93
 
        :param date_range: Retrieve the messages from or between a range of
94
 
            dates. Example: 2012-01-01..2012-01-31 retrieve all the messages
95
 
            between the 01 and 31 of January, including message from 01
96
 
            and 31.
97
84
        :param limit: The maximum number of messages to return.  The server
98
85
            may, at its discretion, return fewer.
99
86
        :param memo: (optional) Opaque identifier describing the position in
121
108
        parameters = {}
122
109
        if message_ids is not None:
123
110
            parameters['message_ids'] = message_ids
124
 
        if date_range is not None:
125
 
            parameters['date_range'] = date_range
126
111
        if limit is not None:
127
112
            parameters['limit'] = limit
128
113
        if memo is not None:
142
127
                raise UnsupportedOrder
143
128
            elif response.reason == UnsupportedDisplayType.__doc__:
144
129
                raise UnsupportedDisplayType
145
 
            elif response.reason == UnparsableDateRange.__doc__:
146
 
                raise UnparsableDateRange
147
130
            else:
148
131
                raise ValueError('Bad request')
149
132
        data = response.read()
150
133
        return simplejson.loads(data)
151
 
 
152
 
    def hide_message(self, archive_id, message_id, hidden):
153
 
        parameters = {
154
 
            'hidden': hidden,
155
 
            }
156
 
        query = {'parameters': simplejson.dumps(parameters)}
157
 
        path = '%s/%s' % (archive_id, message_id)
158
 
        response = self._method_archive('POST', path, query)
159
 
        if response.status == httplib.BAD_REQUEST:
160
 
            if response.reason == MessageIdNotFound.__doc__:
161
 
                raise MessageIdNotFound
162
 
        data = response.read()
163
 
        return simplejson.loads(data)