← Back to branch summary

~openerp-dev/openerp-mobile/openerp-mobile-10

« back to all changes in this revision

Viewing changes to src/com/openerp/addons/meeting/calendar/OECalendar.java

  • Committer: Dharmang Soni (OpenERP)
  • Date: 2014-04-03 07:28:06 UTC
  • Revision ID: dpr@tinyerp.com-20140403072806-qphqroz65ch61pqt
[REMOVE] removed social client module from base framework

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/com/openerp/addons/meeting/calendar/OECalendar.java
1
 
/**
2
 
 * OpenERP, Open Source Management Solution
3
 
 * Copyright (C) 2012-today OpenERP SA (<http://www.openerp.com>)
4
 
 * 
5
 
 * This program is free software: you can redistribute it and/or modify
6
 
 * it under the terms of the GNU Affero General Public License as
7
 
 * published by the Free Software Foundation, either version 3 of the
8
 
 * License, or (at your option) any later version
9
 
 * 
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU Affero General Public License for more details
14
 
 * 
15
 
 * You should have received a copy of the GNU Affero General Public License
16
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
17
 
 * 
18
 
 */
19
 
package com.openerp.addons.meeting.calendar;
20
 
 
21
 
import java.util.ArrayList;
22
 
import java.util.List;
23
 
import java.util.TimeZone;
24
 
 
25
 
import android.accounts.Account;
26
 
import android.content.ContentResolver;
27
 
import android.content.ContentValues;
28
 
import android.content.Context;
29
 
import android.database.Cursor;
30
 
import android.graphics.Color;
31
 
import android.net.Uri;
32
 
import android.provider.CalendarContract;
33
 
import android.provider.CalendarContract.Calendars;
34
 
import android.provider.CalendarContract.Events;
35
 
import android.util.Log;
36
 
 
37
 
import com.openerp.addons.meeting.MeetingDB;
38
 
import com.openerp.auth.OpenERPAccountManager;
39
 
import com.openerp.orm.OEDataRow;
40
 
import com.openerp.orm.OEHelper;
41
 
import com.openerp.orm.OEM2MIds;
42
 
import com.openerp.orm.OEM2MIds.Operation;
43
 
import com.openerp.orm.OEValues;
44
 
import com.openerp.support.OEUser;
45
 
import com.openerp.util.OEDate;
46
 
 
47
 
public class OECalendar {
48
 
 
49
 
        public static final String TAG = "com.openerp.addons.meeting.calendar.OECalendar";
50
 
 
51
 
        Context mContext = null;
52
 
        ContentResolver mContentResolver = null;
53
 
        Account mAccount = null;
54
 
 
55
 
        Long mCalendarId = 0L;
56
 
 
57
 
        MeetingDB mMeetingDB = null;
58
 
 
59
 
        /**
60
 
         * Event Projections
61
 
         */
62
 
        String[] mEventsProjection = new String[] { CalendarContract.Events._ID,
63
 
                        CalendarContract.Events.TITLE, CalendarContract.Events.DESCRIPTION,
64
 
                        CalendarContract.Events.CALENDAR_ID,
65
 
                        CalendarContract.Events.DURATION, CalendarContract.Events.DTSTART,
66
 
                        CalendarContract.Events.DTEND,
67
 
                        CalendarContract.Events.EVENT_LOCATION,
68
 
                        CalendarContract.Events.ALL_DAY };
69
 
 
70
 
        public OECalendar(Context context) {
71
 
                Log.d(TAG, "OECalendar->constructor()");
72
 
                mContext = context;
73
 
                mMeetingDB = new MeetingDB(mContext);
74
 
                mAccount = OpenERPAccountManager.getAccount(mContext,
75
 
                                OEUser.current(mContext).getAndroidName());
76
 
                mContentResolver = mContext.getContentResolver();
77
 
 
78
 
                if (mAccount != null)
79
 
                        initCalendar();
80
 
        }
81
 
 
82
 
        private void initCalendar() {
83
 
                Log.d(TAG, "OECalendar->initCalendar()");
84
 
                Uri mCalendarUri = Calendars.CONTENT_URI;
85
 
 
86
 
                long calendar_id = 0L;
87
 
 
88
 
                String[] projection = new String[] { Calendars._ID,
89
 
                                Calendars.ACCOUNT_NAME, Calendars.CALENDAR_DISPLAY_NAME };
90
 
 
91
 
                String selection = Calendars.ACCOUNT_NAME + " = ? ";
92
 
                String[] selectionArgs = new String[] { mAccount.name };
93
 
 
94
 
                Cursor cr = mContentResolver.query(mCalendarUri, projection, selection,
95
 
                                selectionArgs, null);
96
 
                if (cr.moveToFirst()) {
97
 
                        calendar_id = cr.getLong(cr.getColumnIndex(Calendars._ID));
98
 
                } else {
99
 
                        calendar_id = createCalendar();
100
 
                }
101
 
                cr.close();
102
 
                mCalendarId = calendar_id;
103
 
                cr.close();
104
 
        }
105
 
 
106
 
        private long createCalendar() {
107
 
                Log.d(TAG, "OECalendar->createCalendar()");
108
 
                long calendar_id = 0;
109
 
 
110
 
                ContentValues values = new ContentValues();
111
 
                values.put(Calendars.ACCOUNT_NAME, mAccount.name);
112
 
                values.put(CalendarContract.Calendars.ACCOUNT_TYPE, mAccount.type);
113
 
                values.put(Calendars.NAME, mAccount.name);
114
 
                values.put(Calendars.CALENDAR_DISPLAY_NAME, mAccount.name);
115
 
                values.put(Calendars.CALENDAR_COLOR, Color.parseColor("#cc0000"));
116
 
                values.put(Calendars.CALENDAR_ACCESS_LEVEL, Calendars.CAL_ACCESS_OWNER);
117
 
                values.put(Calendars.OWNER_ACCOUNT, mAccount.name);
118
 
                values.put(Calendars.SYNC_EVENTS, 1);
119
 
                values.put(Calendars.VISIBLE, 1);
120
 
                values.put(CalendarContract.Calendars.CALENDAR_TIME_ZONE, TimeZone
121
 
                                .getDefault().getID());
122
 
                Uri newUri = mContentResolver.insert(getSyncAdapter(), values);
123
 
                calendar_id = Long.parseLong(newUri.getLastPathSegment());
124
 
                Log.d(TAG, "CreateCalendar()->calendar_id = " + calendar_id);
125
 
                return calendar_id;
126
 
        }
127
 
 
128
 
        private Uri getSyncAdapter() {
129
 
                Uri uri = Calendars.CONTENT_URI;
130
 
                return uri
131
 
                                .buildUpon()
132
 
                                .appendQueryParameter(CalendarContract.CALLER_IS_SYNCADAPTER,
133
 
                                                "true")
134
 
                                .appendQueryParameter(Calendars.ACCOUNT_NAME, mAccount.name)
135
 
                                .appendQueryParameter(Calendars.ACCOUNT_TYPE, mAccount.type)
136
 
                                .build();
137
 
        }
138
 
 
139
 
        public void syncCalendar() {
140
 
                Log.d(TAG, "OECalendar->syncCalendar()");
141
 
                Log.i(TAG, "Calendar ID : " + mCalendarId);
142
 
                if (addNewMeetings()) {
143
 
                        List<OEValues> calendarEvents = calendarEvents();
144
 
                        List<Integer> eventIds = new ArrayList<Integer>();
145
 
                        for (OEValues event : calendarEvents)
146
 
                                eventIds.add(event.getInt(CalendarContract.Events._ID));
147
 
                        for (OEDataRow meeting : mMeetingDB.select()) {
148
 
                                int event_id = meeting.getInt("calendar_event_id");
149
 
                                if (eventIds.contains(event_id)) {
150
 
                                        eventIds.remove(eventIds.indexOf(event_id));
151
 
                                }
152
 
                        }
153
 
                        if (pushOnServer(eventIds)) {
154
 
                                updateAllEvents();
155
 
                        }
156
 
                }
157
 
 
158
 
        }
159
 
 
160
 
        private void updateAllEvents() {
161
 
                for (OEDataRow meeting : mMeetingDB.select()) {
162
 
                        updateEvent(meeting);
163
 
                }
164
 
        }
165
 
 
166
 
        private boolean pushOnServer(List<Integer> eventIds) {
167
 
                if (eventIds.size() > 0) {
168
 
                        OEHelper oe = mMeetingDB.getOEInstance();
169
 
                        if (oe != null) {
170
 
                                for (int event_id : eventIds) {
171
 
                                        OEValues values = new OEValues();
172
 
                                        OEValues event = selectEvent(event_id);
173
 
                                        values.put("name",
174
 
                                                        event.getString(CalendarContract.Events.TITLE));
175
 
 
176
 
                                        long startDate = event
177
 
                                                        .getLong(CalendarContract.Events.DTSTART);
178
 
                                        long endDate = event.getLong(CalendarContract.Events.DTEND);
179
 
                                        values.put("date", OEDate.getDateFromMilis(startDate));
180
 
                                        values.put("date_deadline",
181
 
                                                        OEDate.getDateFromMilis(endDate));
182
 
                                        int allday = event.getInt(CalendarContract.Events.ALL_DAY);
183
 
                                        values.put("duration", (allday == 1) ? allday
184
 
                                                        : getDuration(startDate, endDate));
185
 
                                        values.put("allday", (allday == 1) ? true : false);
186
 
                                        values.put("location", event
187
 
                                                        .getString(CalendarContract.Events.EVENT_LOCATION));
188
 
                                        values.put("description", event
189
 
                                                        .getString(CalendarContract.Events.DESCRIPTION));
190
 
 
191
 
                                        List<Integer> partners = new ArrayList<Integer>();
192
 
                                        partners.add(OEUser.current(mContext).getPartner_id());
193
 
                                        OEM2MIds partner_ids = new OEM2MIds(Operation.ADD, partners);
194
 
                                        values.put("partner_ids", partner_ids);
195
 
                                        int newId = oe.create(values);
196
 
                                        values = new OEValues();
197
 
                                        values.put("calendar_event_id", event_id);
198
 
                                        values.put("calendar_id", mCalendarId);
199
 
                                        mMeetingDB.update(values, newId);
200
 
                                }
201
 
                        }
202
 
                }
203
 
                return true;
204
 
        }
205
 
 
206
 
        private float getDuration(long startDate, long endDate) {
207
 
                long offset = endDate - startDate;
208
 
                long datehours = offset / (60 * 60 * 1000);
209
 
                long dateminutes = offset / (60 * 1000);
210
 
                long duration = dateminutes - (datehours * 60);
211
 
                String hour = String.valueOf(datehours);
212
 
                String minute = String.valueOf(duration);
213
 
                StringBuffer durationString = new StringBuffer();
214
 
                durationString.append(hour);
215
 
                durationString.append(".");
216
 
                durationString.append(minute);
217
 
                return Float.parseFloat(durationString.toString());
218
 
        }
219
 
 
220
 
        private boolean addNewMeetings() {
221
 
                Log.d(TAG, "OECalendar->addNewMeetings()");
222
 
                List<OEDataRow> new_meetings = mMeetingDB.select(
223
 
                                "calendar_id IS NULL AND calendar_event_id IS NULL",
224
 
                                new String[] {});
225
 
                for (OEDataRow meeting : new_meetings) {
226
 
                        long new_calendar_event_id = createEvent(meeting);
227
 
                        OEValues values = new OEValues();
228
 
                        values.put("calendar_event_id", new_calendar_event_id);
229
 
                        values.put("calendar_id", mCalendarId);
230
 
                        int count = mMeetingDB.update(values, meeting.getInt("id"));
231
 
                        Log.i(TAG, count + " meeting updated");
232
 
                }
233
 
                return true;
234
 
        }
235
 
 
236
 
        public boolean removeEvents(List<OEDataRow> meetings) {
237
 
                Log.d(TAG, "OECalendar->removeMeetings()");
238
 
                for (OEDataRow row : meetings)
239
 
                        removeEvent(row.getInt("calendar_event_id"));
240
 
                return true;
241
 
        }
242
 
 
243
 
        private OEValues selectEvent(int event_id) {
244
 
                OEValues event = new OEValues();
245
 
                Cursor cr = mContentResolver.query(Events.CONTENT_URI,
246
 
                                mEventsProjection, CalendarContract.Events._ID + " = ?",
247
 
                                new String[] { event_id + "" }, null);
248
 
                if (cr.moveToFirst()) {
249
 
                        for (String key : mEventsProjection) {
250
 
                                int index = cr.getColumnIndex(key);
251
 
                                Object value = "";
252
 
                                if (cr.getString(index) != null)
253
 
                                        value = cr.getString(index);
254
 
                                event.put(key, value);
255
 
                        }
256
 
                }
257
 
                cr.close();
258
 
                return event;
259
 
        }
260
 
 
261
 
        private List<OEValues> calendarEvents() {
262
 
                Log.d(TAG, "OECalendar->calendarEvents()");
263
 
                List<OEValues> events = new ArrayList<OEValues>();
264
 
 
265
 
                Cursor cr = mContentResolver.query(Events.CONTENT_URI,
266
 
                                mEventsProjection, CalendarContract.Events.CALENDAR_ID
267
 
                                                + " = ? ", new String[] { mCalendarId + "" }, null);
268
 
                if (cr.moveToFirst()) {
269
 
                        do {
270
 
                                OEValues event = new OEValues();
271
 
                                for (String key : mEventsProjection) {
272
 
                                        int index = cr.getColumnIndex(key);
273
 
                                        if (cr.getType(index) == Cursor.FIELD_TYPE_INTEGER)
274
 
                                                event.put(key, cr.getInt(index));
275
 
                                        else
276
 
                                                event.put(key, cr.getString(index));
277
 
                                }
278
 
                                events.add(event);
279
 
                        } while (cr.moveToNext());
280
 
                }
281
 
                cr.close();
282
 
                return events;
283
 
        }
284
 
 
285
 
        private boolean removeEvent(int event_id) {
286
 
                Log.d(TAG, "OECalendar->removeEvent()");
287
 
                boolean flag = false;
288
 
                int count = mContentResolver.delete(Events.CONTENT_URI,
289
 
                                CalendarContract.Events._ID + " = ? AND "
290
 
                                                + CalendarContract.Events.CALENDAR_ID + " = ?",
291
 
                                new String[] { event_id + "", mCalendarId + "" });
292
 
                if (count > 0) {
293
 
                        flag = true;
294
 
                        Log.i(TAG, "removedEvent : " + event_id);
295
 
                }
296
 
                return flag;
297
 
        }
298
 
 
299
 
        private long createEvent(OEDataRow meeting) {
300
 
                Log.d(TAG, "OECalendar->createEvent()");
301
 
                long calendar_event_id = 0L;
302
 
                calendar_event_id = Long.parseLong(mContentResolver.insert(
303
 
                                Events.CONTENT_URI, getValues(meeting)).getLastPathSegment());
304
 
                Log.i(TAG, "OECalendar->createEvent() : " + calendar_event_id);
305
 
                return calendar_event_id;
306
 
        }
307
 
 
308
 
        private void updateEvent(OEDataRow meeting) {
309
 
                Log.d(TAG, "OECalendar->updateEvent()");
310
 
                mContentResolver.update(Events.CONTENT_URI, getValues(meeting),
311
 
                                Events._ID + " = ?",
312
 
                                new String[] { meeting.getString("calendar_event_id") });
313
 
                Log.i(TAG,
314
 
                                "OECalendar->updateEvent() : "
315
 
                                                + meeting.getString("calendar_event_id"));
316
 
        }
317
 
 
318
 
        private ContentValues getValues(OEDataRow meeting) {
319
 
                ContentValues values = new ContentValues();
320
 
                values.put(CalendarContract.Events.TITLE, meeting.getString("name"));
321
 
                String description = meeting.getString("description");
322
 
                values.put(CalendarContract.Events.DESCRIPTION,
323
 
                                (description.equals("false")) ? "" : description);
324
 
                values.put(CalendarContract.Events.CALENDAR_ID, mCalendarId);
325
 
                values.put(CalendarContract.Events.DTSTART,
326
 
                                OEDate.getDateTimeInMilis(meeting.getString("date")));
327
 
                values.put(CalendarContract.Events.ALL_DAY,
328
 
                                meeting.getBoolean("allday"));
329
 
 
330
 
                values.put(CalendarContract.Events.DTEND,
331
 
                                OEDate.getDateTimeInMilis(meeting.getString("date_deadline")));
332
 
                String location = meeting.getString("location");
333
 
                values.put(CalendarContract.Events.EVENT_LOCATION,
334
 
                                (location.equals("false")) ? "" : location);
335
 
                values.put(CalendarContract.Events.EVENT_TIMEZONE,
336
 
                                OEUser.current(mContext).getTimezone());
337
 
                return values;
338
 
        }
339
 
}