/
TODO
138 lines (104 loc) · 6.65 KB
/
TODO
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
TODO
=====
- After kronolith gets support for different organizer/owner fields, must
properly set the organizer for meeting responses. Currently, the event
created from a meeting response does not contain the organizer of the original
event. So when the event is sync'd back to the device, it allows the user
to cancel the event and send updates to all attendees. Also, it will then be
possible to automatically add responses to the kronolith event from the
incoming activesync response message.
- Email recurrence related properties for recurring meeting requests.
- SCHEMA support in ITEMOPERATIONS requests. Don't have client that supports
currently.
- Implement some sort of issue tracking/counting to prevent loops due to things
like clients not supporting standard status codes, like FOLDERSYNC_REQUIRED.
Send the error code up to a maximum number of times, and after that send a
server 500-ish error code indicating the client should stop trying. Probably
store data in device object, but need to figure out how to prevent race
conditions since multiple requests can be in progress. Perhaps some sort
of shared memory cache?
- Perhaps if we use a shared memory solution, we can also possibly create
some sort of top-like application to monitor EAS usage. Make it easier to
find troublesome devices etc....
- Work out / more fully test Task recurrence. Especially completion of a single
instance using DEADRECUR etc... (most work is in Nag, but put here to keep
sync todos together).
BC BREAKING (i.e., Horde 6).
============================
- Move all non-specific constants to single class.
- Clean up the various foldertype constant messes. I.e., probably store
the Horde_ActiveSync::FOLDER_TYPE_* and Horde_ActiveSync::CLASS_* values
in the saved state instead of having to switch between them in various
places. (Some client commands are sent using the CLASS, some using the
FOLDER_TYPE).
- Clean up and refactor the folder creation/editing/deleting methods in the
backend. They need to be normalized in accepting/returning the same objects
now that we support multiple folders per non-email collection.
- Refactor Horde_ActiveSync_State_*::listDevices() to return a
Horde_ActiveSync_Device object instead of a hash keyed by backend field names
and to take the object property names as filters instead of backend field names.
- Clean up logger creation/setting/log_level setting.
- Consolidate folderUid <-> backend id mapping methods into a single place.
Currently they live in both the collection handler and the backend driver.
- Refactor out the need for the various static ::_* properties in the main
ActiveSync class.
- Change the readable names of the WBXML tags to reflect what they are called
in the MS-AS* documents, and not what Z-Push's developers decided to call them.
- Look at extracting something like Request_Parser and Request_Handler classes
to separate the reading of the request from the handling of it. The parser
should return some standard request object that can be passed to the handler
that contains the pertinent information. Use temporary streams to hold any
incoming message data to preserve the low memory footprint from dealing with
changes as we read them.
- Maintain the serverid -> backendid map in a single place and stop storing
backend ids (i.e., IMAP folder names) in collection/state/folder cache etc...
- Possibly move the syncCache and state into the device object so we have a
single object to pass around that has access to all.
- Extract a basic Horde_ActiveSync_Storage class? At the very least we need to
rename the current Horde_ActiveSync_State_* classes to Horde_ActiveSync_Storage
since they now deal with more than device state.
- Implmement Horde_ActiveSync_HttpRequest object and remove dependency on
Horde_Controller. We only use the Horde_Controller_Request_Http object from
that package.
- Implmement A Horde_ActiveSync_Response object and move functionality currently
living in the RPC layer (sending back certain headers, etc...) into this
class.
- Implement a Horde_ActiveSync_Change_Filter class/interface. Used to implement
workarounds for broken clients. E.g., filter out the ADD commands sent in
response to MOVEITEMS for Outlook clients. Use a similar pattern for other
types of broken client behavior.
- No longer ignore SMS synchronization in the library, but pass it up to the
backend and the let the backend decide what to do with it. Since the SMS
ability of EAS uses the device to actually send the SMS, I could foresee
some added ability in IMP, or maybe a separate app, that allows managing this.
- Break up Horde_ActiveSync_Driver::getMessage(). Add _getCalendarMessage() etc...
and move base logic for calling the correct method into the base class.
- Decouple the codepage definitions from the Encoder/Decoder class. Break them
out into individual classes.
- Pass the Horde_ActiveSync::FILTERTYPE_ constant directly to the driver, and
let the driver calculate the needed time slice if needed. Needed to correctly
deal with Horde_ActiveSync::FILTERTYPE_INCOMPLETETASKS.
- Introduce some sort of filter or similar data in the definitions of the wbxml
fields to allow for things like specifying the maximum size of a field allowed.
- Move Horde_Core_ActiveSync_Mail into the Horde_ActiveSync library.
Horde_ActiveSync_Mailer (?). This is functionality that should be provided
out of the box from the library. Need to figure out the best way to inject the
Horde specific things, like the actual mailer and identity data.
- Implement something like Horde_ActiveSync_Sync_Options:: to encapsulate loading
and transporting the various collection options/bodyprefs around.
- Likewise, implement a collection object instead of using an array to define
each collection.
- Implement Horde_ActiveSync_SyncKey.
- Move non server-ish methods out of Horde_ActiveSync(_Server). E.g.,
getMimeTrucSize() etc...
- Implment a "changes" object that uses either an array/spl array, or a
temporary php stream (for the larger initial email syncs) to store the actual
change data structure. Needed to avoid hitting PHP memory limit for very large
mailboxes when synchronizing to clients that pull the entire mailbox down
(like Outlook). Also, standardize the data format instead of having to
(re)build a flat array from a multidimensional array of 'changes', 'add' etc..
- Use a configuration object (or maybe a Builder) for constructing the
ActiveSync Driver and Server objects. At the very least, need to clean up the
constructor parameters and various configuration options mess. (E.g., the
"PING" configuration values are no longer really all strictly related to PING
requests).