зеркало из https://github.com/mozilla/gecko-dev.git
1102 строки
38 KiB
JavaScript
1102 строки
38 KiB
JavaScript
/* -*- Mode: javascript; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is Oracle Corporation code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Oracle Corporation
|
|
* Portions created by the Initial Developer are Copyright (C) 2004
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Vladimir Vukicevic <vladimir.vukicevic@oracle.com>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
//
|
|
// calStorageCalendar.js
|
|
//
|
|
|
|
const kStorageServiceContractID = "@mozilla.org/storage/service;1";
|
|
const kStorageServiceIID = Components.interfaces.mozIStorageService;
|
|
|
|
const kCalICalendar = Components.interfaces.calICalendar;
|
|
|
|
const kCalEventContractID = "@mozilla.org/calendar/event;1";
|
|
const kCalIEvent = Components.interfaces.calIEvent;
|
|
const CalEvent = new Components.Constructor(kCalEventContractID, kCalIEvent);
|
|
|
|
const kCalTodoContractID = "@mozilla.org/calendar/todo;1";
|
|
const kCalITodo = Components.interfaces.calITodo;
|
|
const CalTodo = new Components.Constructor(kCalTodoContractID, kCalITodo);
|
|
|
|
const kCalDateTimeContractID = "@mozilla.org/calendar/datetime;1";
|
|
const kCalIDateTime = Components.interfaces.calIDateTime;
|
|
const CalDateTime = new Components.Constructor(kCalDateTimeContractID, kCalIDateTime);
|
|
|
|
const kCalAttendeeContractID = "@mozilla.org/calendar/attendee;1";
|
|
const kCalIAttendee = Components.interfaces.calIAttendee;
|
|
const CalAttendee = new Components.Constructor(kCalAttendeeContractID, kCalIAttendee);
|
|
|
|
const kCalItemOccurrenceContractID = "@mozilla.org/calendar/item-occurrence;1";
|
|
const kCalIItemOccurrence = Components.interfaces.calIItemOccurrence;
|
|
const CalItemOccurrence = new Components.Constructor(kCalItemOccurrenceContractID, kCalIItemOccurrence);
|
|
|
|
const kCalRecurrenceInfoContractID = "@mozilla.org/calendar/recurrence-info;1";
|
|
const kCalIRecurrenceInfo = Components.interfaces.calIRecurrenceInfo;
|
|
const CalRecurrenceInfo = new Components.Constructor(kCalRecurrenceInfoContractID, kCalIRecurrenceInfo);
|
|
|
|
const kMozStorageStatementWrapperContractID = "@mozilla.org/storage/statement-wrapper;1";
|
|
const kMozStorageStatementWrapperIID = Components.interfaces.mozIStorageStatementWrapper;
|
|
if (kMozStorageStatementWrapperIID) {
|
|
const MozStorageStatementWrapper = new Components.Constructor(kMozStorageStatementWrapperContractID, kMozStorageStatementWrapperIID);
|
|
} else {
|
|
dump("*** mozStorage not available, calendar/storage provider will not function\n");
|
|
}
|
|
|
|
const CAL_ITEM_TYPE_EVENT = 0;
|
|
const CAL_ITEM_TYPE_TODO = 1;
|
|
|
|
// bitmasks
|
|
const CAL_ITEM_FLAG_PRIVATE = 1;
|
|
const CAL_ITEM_FLAG_HAS_ATTENDEES = 2;
|
|
const CAL_ITEM_FLAG_HAS_PROPERTIES = 4;
|
|
const CAL_ITEM_FLAG_EVENT_ALLDAY = 8;
|
|
const CAL_ITEM_FLAG_HAS_RECURRENCE = 16;
|
|
|
|
//
|
|
// Storage helpers
|
|
//
|
|
|
|
function createStatement (dbconn, sql) {
|
|
var stmt = dbconn.createStatement(sql);
|
|
var wrapper = MozStorageStatementWrapper();
|
|
wrapper.initialize(stmt);
|
|
return wrapper;
|
|
}
|
|
|
|
//
|
|
// other helpers
|
|
//
|
|
|
|
function newDateTime(aPRTime) {
|
|
var t = CalDateTime();
|
|
t.isUtc = true;
|
|
t.nativeTime = aPRTime;
|
|
return t;
|
|
}
|
|
|
|
function makeOccurrence(item, start, end)
|
|
{
|
|
var occ = CalItemOccurrence();
|
|
// XXX poor form
|
|
occ.wrappedJSObject.item = item;
|
|
occ.wrappedJSObject.occurrenceStartDate = start;
|
|
occ.wrappedJSObject.occurrenceEndDate = end;
|
|
return occ;
|
|
}
|
|
|
|
//
|
|
// calStorageCalendar
|
|
//
|
|
|
|
function calStorageCalendar(cal_id) {
|
|
this.wrappedJSObject = this;
|
|
|
|
if (cal_id)
|
|
this.mCalId = cal_id;
|
|
}
|
|
|
|
calStorageCalendar.prototype = {
|
|
//
|
|
// private members
|
|
//
|
|
mObservers: Array(),
|
|
mDB: null,
|
|
mDBTwo: null,
|
|
mItemCache: Array(),
|
|
mCalId: 0,
|
|
|
|
//
|
|
// nsISupports interface
|
|
//
|
|
QueryInterface: function (aIID) {
|
|
if (!aIID.equals(Components.interfaces.nsISupports) &&
|
|
!aIID.equals(Components.interfaces.calICalendar))
|
|
{
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
//
|
|
// calICalendar interface
|
|
//
|
|
|
|
mURI: null,
|
|
// attribute nsIURI uri;
|
|
get uri() { return this.mURI; },
|
|
set uri(aURI) {
|
|
// we can only load once
|
|
if (this.mURI)
|
|
throw Components.results.NS_ERROR_FAILURE;
|
|
|
|
// we can only load storage bits from a file
|
|
var fileURL = aURI.QueryInterface(Components.interfaces.nsIFileURL);
|
|
if (!fileURL)
|
|
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
// open the database
|
|
var dbService = Components.classes[kStorageServiceContractID].getService(kStorageServiceIID);
|
|
this.mDB = dbService.openDatabase (fileURL.file);
|
|
this.mDBTwo = dbService.openDatabase (fileURL.file);
|
|
|
|
this.initDB();
|
|
|
|
this.mURI = aURI;
|
|
},
|
|
|
|
// attribute boolean readOnly;
|
|
get readOnly() { return false; },
|
|
set readOnly() { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; },
|
|
|
|
// attribute boolean suppressAlarms;
|
|
get suppressAlarms() { return false; },
|
|
set suppressAlarms(aSuppressAlarms) { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; },
|
|
|
|
// void addObserver( in calIObserver observer, in unsigned long aItemFilter );
|
|
addObserver: function (aObserver, aItemFilter) {
|
|
for (var i = 0; i < this.mObservers.length; i++) {
|
|
if (this.mObservers[i].observer == aObserver &&
|
|
this.mObservers[i].filter == aItemFilter)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
this.mObservers.push( {observer: aObserver, filter: aItemFilter} );
|
|
},
|
|
|
|
// void removeObserver( in calIObserver observer );
|
|
removeObserver: function (aObserver) {
|
|
var newObservers = Array();
|
|
for (var i = 0; i < this.mObservers.length; i++) {
|
|
if (this.mObservers[i].observer != aObserver)
|
|
newObservers.push(this.mObservers[i]);
|
|
}
|
|
this.mObservers = newObservers;
|
|
},
|
|
|
|
// void addItem( in calIItemBase aItem, in calIOperationListener aListener );
|
|
addItem: function (aItem, aListener) {
|
|
if (aItem.id == null) {
|
|
// is this an error? Or should we generate an IID?
|
|
aItem.id = "uuid:" + (new Date()).getTime();
|
|
} else {
|
|
var olditem = this.getItemById(aItem.id);
|
|
if (olditem) {
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_ERROR_FAILURE,
|
|
aListener.ADD,
|
|
aItem.id,
|
|
"ID already exists for addItem");
|
|
return;
|
|
}
|
|
}
|
|
|
|
var newItem = aItem.clone();
|
|
newItem.parent = this;
|
|
newItem.generation = 1;
|
|
newItem.makeImmutable();
|
|
|
|
dump ("about to flushItem\n");
|
|
dump ("newitem.recurrenceInfo: " + newItem.recurrenceInfo + " aItem.recurrenceInfo: " + aItem.recurrenceInfo + "\n");
|
|
this.flushItem (newItem, null);
|
|
dump ("after flushItem\n");
|
|
|
|
// notify the listener
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_OK,
|
|
aListener.ADD,
|
|
newItem.id,
|
|
newItem);
|
|
|
|
// notify observers
|
|
this.observeAddItem(newItem);
|
|
},
|
|
|
|
// void modifyItem( in calIItemBase aItem, in calIOperationListener aListener );
|
|
modifyItem: function (aItem, aListener) {
|
|
if (aItem.id == null) {
|
|
// this is definitely an error
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_ERROR_FAILURE,
|
|
aListener.MODIFY,
|
|
aItem.id,
|
|
"ID for modifyItem item is null");
|
|
return;
|
|
}
|
|
|
|
// get the old item
|
|
var olditem = this.getItemById(aItem.id);
|
|
if (!olditem) {
|
|
// no old item found? should be using addItem, then.
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_ERROR_FAILURE,
|
|
aListener.MODIFY,
|
|
aItem.id,
|
|
"ID does not already exit for modifyItem");
|
|
return;
|
|
}
|
|
|
|
if (olditem.generation != aItem.generation) {
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_ERROR_FAILURE,
|
|
aListener.MODIFY,
|
|
aItem.id,
|
|
"generation too old for for modifyItem");
|
|
return;
|
|
}
|
|
|
|
var newItem = aItem.clone();
|
|
newItem.generation += 1;
|
|
newItem.makeImmutable();
|
|
|
|
this.flushItem (newItem, olditem);
|
|
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_OK,
|
|
aListener.MODIFY,
|
|
newItem.id,
|
|
newItem);
|
|
|
|
// notify observers
|
|
this.observeModifyItem(newItem, olditem);
|
|
},
|
|
|
|
// void deleteItem( in string id, in calIOperationListener aListener );
|
|
deleteItem: function (aItem, aListener) {
|
|
dump ("deleteItem\n");
|
|
if (aItem.id == null) {
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_ERROR_FAILURE,
|
|
aListener.DELETE,
|
|
aId,
|
|
"ID is null for deleteItem");
|
|
return;
|
|
}
|
|
|
|
this.deleteItemById(aItem.id);
|
|
|
|
if (aListener)
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_OK,
|
|
aListener.DELETE,
|
|
aItem.id,
|
|
null);
|
|
|
|
// notify observers
|
|
this.observeDeleteItem(aItem);
|
|
},
|
|
|
|
// void getItem( in string id, in calIOperationListener aListener );
|
|
getItem: function (aId, aListener) {
|
|
if (!aListener)
|
|
return;
|
|
|
|
var item = this.getItemById (aId);
|
|
if (!item) {
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_ERROR_FAILURE,
|
|
aListener.GET,
|
|
aID,
|
|
"ID doesn't exist for getItem");
|
|
}
|
|
|
|
var item_iid = null;
|
|
if (item instanceof kCalIEvent)
|
|
item_iid = kCalIEvent;
|
|
else if (item instanceof kCalITodo)
|
|
item_iid = kCalITodo;
|
|
else {
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_ERROR_FAILURE,
|
|
aListener.GET,
|
|
aId,
|
|
"Can't deduce item type based on QI");
|
|
return;
|
|
}
|
|
|
|
aListener.onGetResult (Components.results.NS_OK,
|
|
item_iid, null,
|
|
1, [item]);
|
|
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_OK,
|
|
aListener.GET,
|
|
aId,
|
|
null);
|
|
},
|
|
|
|
// void getItems( in unsigned long aItemFilter, in unsigned long aCount,
|
|
// in calIDateTime aRangeStart, in calIDateTime aRangeEnd,
|
|
// in calIOperationListener aListener );
|
|
getItems: function (aItemFilter, aCount,
|
|
aRangeStart, aRangeEnd, aListener)
|
|
{
|
|
if (!aListener)
|
|
return;
|
|
|
|
var itemsFound = Array();
|
|
var startTime = 0;
|
|
// endTime needs to be the max value a PRTime can be
|
|
var endTime = 0x7fffffffffffffff;
|
|
if (aRangeStart)
|
|
startTime = aRangeStart.nativeTime;
|
|
if (aRangeEnd)
|
|
endTime = aRangeEnd.nativeTime;
|
|
|
|
// only events for now
|
|
var wantEvents = ((aItemFilter & kCalICalendar.ITEM_FILTER_TYPE_EVENT) != 0);
|
|
var wantTodos = ((aItemFilter & kCalICalendar.ITEM_FILTER_TYPE_TODO) != 0);
|
|
var asOccurrences = ((aItemFilter & kCalICalendar.ITEM_FILTER_CLASS_OCCURRENCES) != 0);
|
|
|
|
if (!wantEvents && !wantTodos) {
|
|
// nothing to do
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_OK,
|
|
aListener.GET,
|
|
null,
|
|
null);
|
|
return;
|
|
}
|
|
|
|
var stmt;
|
|
if (asOccurrences)
|
|
stmt = this.mSelectItemsByRangeWithRecurrence;
|
|
else
|
|
stmt = this.mSelectItemsByRange;
|
|
stmt.reset();
|
|
var sp = stmt.params;
|
|
sp.cal_id = this.mCalId;
|
|
sp.event_start = startTime;
|
|
sp.event_end = endTime;
|
|
sp.todo_start = startTime;
|
|
sp.todo_end = endTime;
|
|
|
|
dump ("SELECT ITEMS: start: " + startTime + " end: " + endTime + "\n");
|
|
|
|
/*
|
|
if (asOccurrences) {
|
|
sp.event_start2 = startTime;
|
|
sp.event_end2 = endTime;
|
|
}
|
|
*/
|
|
var count = 0;
|
|
while (stmt.step()) {
|
|
var iid;
|
|
if (stmt.row.item_type == CAL_ITEM_TYPE_EVENT) {
|
|
if (!wantEvents)
|
|
continue;
|
|
iid = kCalIEvent;
|
|
} else if (stmt.row.item_type == CAL_ITEM_TYPE_TODO) {
|
|
if (!wantTodos)
|
|
continue;
|
|
iid = kCalITodo;
|
|
} else {
|
|
// errrr..
|
|
dump ("***** Unknown item type in db: " + stmt.row.item_type + "\n");
|
|
continue;
|
|
}
|
|
var flags = {};
|
|
var item = this.getItemFromRow(stmt.row, flags);
|
|
// uses mDBTwo, so can be interleaved
|
|
this.getAdditionalDataForItem(item, flags.value);
|
|
|
|
item.makeImmutable();
|
|
|
|
var items = null;
|
|
|
|
dump ("RINFO: " + item.recurrenceInfo + "\n");
|
|
if (item.recurrenceInfo && item.recurrenceInfo.recurType != 0) {
|
|
dump ("GETOCCURRENCESBETWEEN " + aRangeStart.jsDate + " -> " + aRangeEnd.jsDate + "\n");
|
|
iid = kCalIItemOccurrence;
|
|
items = item.recurrenceInfo.getOccurrencesBetween (item, aRangeStart, aRangeEnd, {});
|
|
dump ("items: " + items + "\n");
|
|
dump ("GOT : " + items.length + "\n");
|
|
for (var i = 0; i < items.length; i++) {
|
|
var q = items[i];
|
|
dump ("item " + i + " " + q.item.title + ": " + q.occurrenceStartDate.jsDate + " -> " + q.occurrenceEndDate + "\n");
|
|
}
|
|
} else {
|
|
if (asOccurrences) {
|
|
if (iid == kCalIEvent) {
|
|
item = makeOccurrence(item, item.startDate, item.endDate);
|
|
} else if (iid == kCalITodo) {
|
|
item = makeOccurrence(item, item.entryTime, item.entryTime);
|
|
}
|
|
iid = kCalIItemOccurrence;
|
|
}
|
|
items = [ item ];
|
|
}
|
|
|
|
aListener.onGetResult (this,
|
|
Components.results.NS_OK,
|
|
iid, null,
|
|
items.length, items);
|
|
|
|
count++;
|
|
if (aCount && count == aCount)
|
|
break;
|
|
}
|
|
|
|
stmt.reset();
|
|
|
|
aListener.onOperationComplete (this,
|
|
Components.results.NS_OK,
|
|
aListener.GET,
|
|
null,
|
|
null);
|
|
},
|
|
|
|
//
|
|
// Helper functions
|
|
//
|
|
observeLoad: function () {
|
|
for (var i = 0; i < this.mObservers.length; i++)
|
|
this.mObservers[i].observer.onLoad ();
|
|
},
|
|
|
|
observeBatchChange: function (aNewBatchMode) {
|
|
for (var i = 0; i < this.mObservers.length; i++) {
|
|
if (aNewBatchMode)
|
|
this.mObservers[i].observer.onStartBatch ();
|
|
else
|
|
this.mObservers[i].observer.onEndBatch ();
|
|
}
|
|
},
|
|
|
|
observeAddItem: function (aItem) {
|
|
for (var i = 0; i < this.mObservers.length; i++)
|
|
this.mObservers[i].observer.onAddItem (aItem);
|
|
},
|
|
|
|
observeModifyItem: function (aOldItem, aNewItem) {
|
|
for (var i = 0; i < this.mObservers.length; i++)
|
|
this.mObservers[i].observer.onModifyItem (aOldItem, aNewItem);
|
|
},
|
|
|
|
observeDeleteItem: function (aDeletedItem) {
|
|
for (var i = 0; i < this.mObservers.length; i++)
|
|
this.mObservers[i].observer.onDeleteItem (aDeletedItem);
|
|
},
|
|
|
|
//
|
|
// database handling
|
|
//
|
|
|
|
// initialize the database schema.
|
|
// needs to do some version checking
|
|
initDBSchema: function () {
|
|
dump ("cal_calendars\n");
|
|
this.mDB.createTable ("cal_calendars", sqlTables.cal_calendars);
|
|
dump ("cal_items\n");
|
|
this.mDB.createTable ("cal_items", sqlTables.cal_items);
|
|
dump ("cal_attendees\n");
|
|
this.mDB.createTable ("cal_attendees", sqlTables.cal_attendees);
|
|
dump ("cal_alarms\n");
|
|
this.mDB.createTable ("cal_alarms", sqlTables.cal_alarms);
|
|
dump ("cal_recurrence\n");
|
|
this.mDB.createTable ("cal_recurrence", sqlTables.cal_recurrence);
|
|
dump ("cal_properties\n");
|
|
this.mDB.createTable ("cal_properties", sqlTables.cal_properties);
|
|
},
|
|
|
|
// database initialization
|
|
// assumes mDB is valid
|
|
initDB: function () {
|
|
try {
|
|
this.initDBSchema();
|
|
} catch (e) {
|
|
dump ("initDBSchema error: " + this.mDB.lastErrorString + "\n");
|
|
// ignored
|
|
}
|
|
|
|
// select statements
|
|
this.mSelectItem = createStatement (
|
|
this.mDB,
|
|
"SELECT * FROM cal_items " +
|
|
"WHERE id = :id AND cal_id = :cal_id "+
|
|
"LIMIT 1"
|
|
);
|
|
|
|
this.mSelectItemsByRange = createStatement(
|
|
this.mDB,
|
|
"SELECT * FROM cal_items " +
|
|
"WHERE (item_type = 0 AND (event_end >= :event_start AND event_start <= :event_end)) " +
|
|
" OR (item_type = 1 AND (todo_entry >= :todo_start AND todo_entry <= :todo_end)) " +
|
|
" AND cal_id = :cal_id"
|
|
);
|
|
|
|
this.mSelectItemsByRangeWithRecurrence = createStatement(
|
|
this.mDB,
|
|
"SELECT * FROM cal_items " +
|
|
"WHERE (item_type = 0 AND ((flags & 16 == 0) AND (event_end >= :event_start AND event_start <= :event_end) " +
|
|
" OR (flags & 16 == 16)))" +
|
|
" OR (item_type = 1 AND (flags & 16 == 0) AND todo_entry >= :todo_start AND todo_entry <= :todo_end) " +
|
|
" AND cal_id = :cal_id"
|
|
);
|
|
|
|
// For the extra-item data, note that we use mDBTwo, so that
|
|
// these can be executed while a selectItems is running!
|
|
this.mSelectAttendeesForItem = createStatement(
|
|
this.mDBTwo,
|
|
"SELECT * FROM cal_attendees " +
|
|
"WHERE item_id = :item_id"
|
|
);
|
|
|
|
this.mSelectPropertiesForItem = createStatement(
|
|
this.mDBTwo,
|
|
"SELECT * FROM cal_properties " +
|
|
"WHERE item_id = :item_id"
|
|
);
|
|
|
|
this.mSelectRecurrenceForItem = createStatement(
|
|
this.mDBTwo,
|
|
"SELECT * FROM cal_recurrence " +
|
|
"WHERE item_id = :item_id"
|
|
);
|
|
|
|
// insert statements
|
|
this.mInsertItem = createStatement (
|
|
this.mDB,
|
|
"INSERT INTO cal_items " +
|
|
" (cal_id, item_type, id, time_created, last_modified, " +
|
|
" title, priority, privacy, ical_status, flags, " +
|
|
" event_start, event_end, event_stamp, todo_entry, todo_due, " +
|
|
" todo_completed, todo_complete, recur_end) " +
|
|
"VALUES (:cal_id, :item_type, :id, :time_created, :last_modified, " +
|
|
" :title, :priority, :privacy, :ical_status, :flags, " +
|
|
" :event_start, :event_end, :event_stamp, :todo_entry, :todo_due, " +
|
|
" :todo_completed, :todo_complete, :recur_end)"
|
|
);
|
|
this.mInsertAlarm = createStatement (
|
|
this.mDB,
|
|
"INSERT INTO cal_alarms (alarm_data) " +
|
|
"VALUES (:alarm_data)"
|
|
);
|
|
this.mInsertProperty = createStatement (
|
|
this.mDB,
|
|
"INSERT INTO cal_properties (item_id, key, value) " +
|
|
"VALUES (:item_id, :key, :value)"
|
|
);
|
|
this.mInsertAttendee = createStatement (
|
|
this.mDB,
|
|
"INSERT INTO cal_attendees " +
|
|
" (item_id, attendee_id, common_name, rsvp, role, status, type) " +
|
|
"VALUES (:item_id, :attendee_id, :common_name, :rsvp, :role, :status, :type)"
|
|
);
|
|
this.mInsertRecurrence = createStatement (
|
|
this.mDB,
|
|
"INSERT INTO cal_recurrence " +
|
|
" (item_id, recur_type, count, interval, second, minute, hour, day, monthday, yearday, weekno, month, setpos) " +
|
|
"VALUES (:item_id, :recur_type, :count, :interval, :second, :minute, :hour, :day, :monthday, :yearday, :weekno, :month, :setpos)"
|
|
);
|
|
|
|
// delete statements
|
|
this.mDeleteItem = createStatement (
|
|
this.mDB,
|
|
"DELETE FROM cal_items WHERE id = :id AND cal_id = :cal_id"
|
|
);
|
|
this.mDeleteAttendees = createStatement (
|
|
this.mDB,
|
|
"DELETE FROM cal_attendees WHERE item_id = :item_id"
|
|
);
|
|
this.mDeleteProperties = createStatement (
|
|
this.mDB,
|
|
"DELETE FROM cal_properties WHERE item_id = :item_id"
|
|
);
|
|
this.mDeleteRecurrence = createStatement (
|
|
this.mDB,
|
|
"DELETE FROM cal_recurrence WHERE item_id = :item_id"
|
|
);
|
|
},
|
|
|
|
|
|
// database helper functions
|
|
|
|
// read in the common ItemBase attributes from aDBRow, and stick
|
|
// them on aItemBase
|
|
getItemFromRow: function (row, flags) {
|
|
var item;
|
|
|
|
if (row.cal_id != this.mCalId) {
|
|
// the row selected doesn't belong to this calendar, hmm.
|
|
|
|
throw Components.results.NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// create a new item based on the type from the db
|
|
if (row.item_type == CAL_ITEM_TYPE_EVENT)
|
|
item = CalEvent();
|
|
else if (row.item_type == CAL_ITEM_TYPE_TODO)
|
|
item = CalTodo();
|
|
else
|
|
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
// fill in common bits
|
|
item.creationDate = newDateTime(row.time_created);
|
|
item.lastModifiedTime = newDateTime(row.last_modified);
|
|
item.parent = this;
|
|
item.id = row.id;
|
|
item.title = row.title;
|
|
item.priority = row.priority;
|
|
item.privacy = row.privacy;
|
|
item.status = row.ical_status;
|
|
|
|
if (row.item_type == CAL_ITEM_TYPE_EVENT) {
|
|
item.startDate = newDateTime(row.event_start);
|
|
item.endDate = newDateTime(row.event_end);
|
|
item.stampDate = newDateTime(row.event_stamp);
|
|
item.isAllDay = ((row.flags & CAL_ITEM_FLAG_EVENT_ALLDAY) != 0);
|
|
} else if (row.item_type == CAL_ITEM_TYPE_TODO) {
|
|
item.entryTime = newDateTime(row.todo_entry);
|
|
item.dueDate = newDateTime(row.todo_due);
|
|
item.completedDate = newDateTime(row.todo_complete);
|
|
item.percentComplete = row.todo_complete;
|
|
}
|
|
|
|
// we need a way to do this without using wrappedJSObject
|
|
item.wrappedJSObject.storage_calendar_id = row.id;
|
|
|
|
if (flags)
|
|
flags.value = row.flags;
|
|
|
|
return item;
|
|
},
|
|
|
|
// after we get the base item, we need to check if we need to pull in
|
|
// any extra data from other tables. We do that here.
|
|
|
|
// note that we use mDBTwo for this, so this can be run while a
|
|
// select is executing; don't use any statements that aren't
|
|
// against mDBTwo in here!
|
|
|
|
getAdditionalDataForItem: function (item, flags) {
|
|
if (flags & CAL_ITEM_FLAG_HAS_ATTENDEES) {
|
|
this.mSelectAttendeesForItem.params.event_id = item.id;
|
|
while (this.mSelectAttendeesForItem.step()) {
|
|
var attendee = this.mNewAttendeeFromRow(this.mSelectAttendeesForItem.row);
|
|
item.addAttendee(attendee);
|
|
}
|
|
this.mSelectAttendeesForItem.reset();
|
|
}
|
|
|
|
if (flags & CAL_ITEM_FLAG_HAS_PROPERTIES) {
|
|
this.mSelectPropertiesForItem.params.item_id = item.id;
|
|
// ...
|
|
}
|
|
|
|
if (flags & CAL_ITEM_FLAG_HAS_RECURRENCE) {
|
|
dump ("item " + item.id + " has recurrence\n");
|
|
this.mSelectRecurrenceForItem.params.item_id = item.id;
|
|
if (this.mSelectRecurrenceForItem.step()) {
|
|
var row = this.mSelectRecurrenceForItem.row;
|
|
var rec = new CalRecurrenceInfo();
|
|
|
|
rec.recurType = row.recur_type;
|
|
rec.recurCount = row.count;
|
|
rec.interval = row.interval;
|
|
|
|
if (item instanceof kCalIEvent)
|
|
rec.recurStart = item.startDate;
|
|
else if (item instanceof kCalITodo)
|
|
rec.recurStart = item.entryTime;
|
|
|
|
var rtypes = [kCalIRecurrenceInfo.CAL_RECUR_BYSECOND, "second",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYMINUTE, "minute",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYHOUR, "hour",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYDAY, "day",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYMONTHDAY, "monthday",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYYEARDAY, "yearday",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYWEEKNO, "weekno",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYMONTH, "month",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYSETPOS, "setpos"];
|
|
|
|
for (var i = 0; i < rtypes.length; i += 2) {
|
|
if (row[rtypes[i+1]]) {
|
|
var rstr = row[rtypes[i+1]].split(",");
|
|
var rarray = [];
|
|
for (var j = 0; j < rstr.length; j++) {
|
|
rarray[j] = parseInt(rstr[j]);
|
|
}
|
|
|
|
rec.setComponent (rtypes[i], rarray.length, rarray);
|
|
}
|
|
}
|
|
|
|
item.recurrenceInfo = rec;
|
|
} else {
|
|
dump ("+++ Expected to find recurrence for item " + item.id + ", but found none\n");
|
|
}
|
|
this.mSelectRecurrenceForItem.reset();
|
|
}
|
|
},
|
|
|
|
newAttendeeFromRow: function (row) {
|
|
var a = CalAttendee();
|
|
|
|
a.id = row.attendee_id;
|
|
a.commonName = row.common_name;
|
|
a.rsvp = (row.rsvp != 0);
|
|
a.role = row.role;
|
|
a.participationStatus = row.status;
|
|
a.userType = row.type;
|
|
|
|
return a;
|
|
},
|
|
|
|
//
|
|
// get item from db or from cache with given iid
|
|
//
|
|
getItemById: function (aID) {
|
|
// cached?
|
|
if (this.mItemCache[aID] != null)
|
|
return this.mItemCache[aID];
|
|
|
|
var retval = null;
|
|
|
|
// not cached; need to read from the db
|
|
this.mSelectItem.params.id = aID;
|
|
this.mSelectItem.params.cal_id = this.mCalId;
|
|
if (!this.mSelectItem.step()) {
|
|
// not found
|
|
return null;
|
|
}
|
|
|
|
var flags = {};
|
|
var item = this.getItemFromRow(this.mSelectItem.row, flags);
|
|
this.mSelectItem.reset();
|
|
|
|
this.getAdditionalDataForItem(item, flags.value);
|
|
|
|
item.makeImmutable();
|
|
|
|
// cache it
|
|
this.mItemCache[aID] = item;
|
|
|
|
return item;
|
|
},
|
|
|
|
// write this item's changed data to the db. olditem may be null
|
|
flushItem: function (item, olditem) {
|
|
// for now, we just delete and insert
|
|
// set up params before transaction
|
|
|
|
if (olditem) {
|
|
this.mDeleteItem.params.id = olditem.id;
|
|
this.mDeleteItem.params.cal_id = this.mCalId;
|
|
this.mDeleteAttendees.params.item_id = olditem.id;
|
|
this.mDeleteProperties.params.item_id = olditem.id;
|
|
this.mDeleteRecurrence.params.item_id = olditem.id;
|
|
}
|
|
|
|
var ip = this.mInsertItem.params;
|
|
ip.cal_id = this.mCalId;
|
|
ip.id = item.id;
|
|
ip.time_created = item.creationDate.jsDate;
|
|
ip.last_modified = item.lastModifiedTime.jsDate;
|
|
ip.title = item.title;
|
|
ip.priority = item.priority;
|
|
ip.privacy = item.privacy;
|
|
ip.ical_status = item.status;
|
|
|
|
var flags = 0;
|
|
if (item instanceof kCalIEvent) {
|
|
ip.item_type = CAL_ITEM_TYPE_EVENT;
|
|
|
|
if (item.isAllDay)
|
|
flags |= CAL_ITEM_FLAG_EVENT_ALLDAY;
|
|
|
|
ip.event_start = item.startDate.jsDate;
|
|
ip.event_end = item.endDate.jsDate;
|
|
ip.event_stamp = item.stampDate.jsDate;
|
|
} else if (item instanceof kCalITodo) {
|
|
ip.item_type = CAL_ITEM_TYPE_TODO;
|
|
|
|
ip.todo_entry = item.entryTime.jsDate;
|
|
ip.todo_due = item.dueDate.jsDate;
|
|
ip.todo_completed = item.completedDate.jsDate;
|
|
ip.todo_complete = item.percentComplete;
|
|
} else {
|
|
// XXX fixme error
|
|
throw Components.results.NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// start the transaction
|
|
this.mDB.beginTransaction();
|
|
try {
|
|
if (olditem) {
|
|
this.mDeleteRecurrence.step();
|
|
this.mDeleteAttendees.step();
|
|
this.mDeleteProperties.step();
|
|
this.mDeleteItem.step();
|
|
|
|
this.mDeleteRecurrence.reset();
|
|
this.mDeleteAttendees.reset();
|
|
this.mDeleteProperties.reset();
|
|
this.mDeleteItem.reset();
|
|
}
|
|
|
|
var attendees = item.getAttendees({});
|
|
if (attendees && attendees.length > 0) {
|
|
flags |= CAL_ITEM_FLAG_HAS_ATTENDEES;
|
|
for (var i = 0; i < attendees.length; i++) {
|
|
var a = attendees[i];
|
|
var ap = this.mInsertAttendee.params;
|
|
ap.item_id = item.id;
|
|
ap.attendee_id = a.id;
|
|
ap.common_name = a.commonName;
|
|
ap.rsvp = a.rsvp;
|
|
ap.role = a.role;
|
|
ap.status = a.participationStatus;
|
|
ap.type = a.userType;
|
|
|
|
this.mInsertAttendee.step();
|
|
this.mInsertAttendee.reset();
|
|
}
|
|
}
|
|
|
|
var rec = item.recurrenceInfo;
|
|
dump ("+++++++++++ REC: " + rec + "\n");
|
|
if (rec)
|
|
dump ("++++++++++ type: " + rec.recurType + "\n");
|
|
if (rec && rec.recurType != 0) {
|
|
flags |= CAL_ITEM_FLAG_HAS_RECURRENCE;
|
|
var ap = this.mInsertRecurrence.params;
|
|
ap.item_id = item.id;
|
|
ap.recur_type = rec.recurType;
|
|
ap.count = rec.recurCount;
|
|
ap.interval = rec.interval;
|
|
|
|
var rtypes = [kCalIRecurrenceInfo.CAL_RECUR_BYSECOND, "second",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYMINUTE, "minute",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYHOUR, "hour",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYDAY, "day",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYMONTHDAY, "monthday",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYYEARDAY, "yearday",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYWEEKNO, "weekno",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYMONTH, "month",
|
|
kCalIRecurrenceInfo.CAL_RECUR_BYSETPOS, "setpos"];
|
|
for (var i = 0; i < rtypes.length; i += 2) {
|
|
var comps = rec.getComponent(rtypes[i], {});
|
|
if (comps && comps.length > 0) {
|
|
var compstr = comps.join(",");
|
|
ap[rtypes[i+1]] = compstr;
|
|
}
|
|
}
|
|
|
|
this.mInsertRecurrence.step();
|
|
this.mInsertRecurrence.reset();
|
|
|
|
// also set the item recurrence end
|
|
if (rec.recurEnd)
|
|
ip.recur_end = rec.recurEnd.jsDate;
|
|
}
|
|
|
|
ip.flags = flags;
|
|
this.mInsertItem.step();
|
|
this.mDB.commitTransaction();
|
|
} catch (e) {
|
|
dump ("EXCEPTION; error is: " + this.mDB.lastErrorString + "\n");
|
|
dump (e);
|
|
this.mDB.rollbackTransaction();
|
|
}
|
|
|
|
this.mItemCache[item.id] = item;
|
|
},
|
|
|
|
// delete the event with the given uid
|
|
deleteItemById: function (aID) {
|
|
this.mDeleteItem.params.id = aID;
|
|
this.mDeleteItem.params.cal_id = this.mCalId;
|
|
this.mDeleteAttendees.params.item_id = aID;
|
|
this.mDeleteProperties.params.item_id = aID;
|
|
this.mDeleteRecurrence.params.item_id = aID;
|
|
|
|
this.mDB.beginTransaction();
|
|
try {
|
|
this.mDeleteRecurrence.step();
|
|
this.mDeleteAttendees.step();
|
|
this.mDeleteProperties.step();
|
|
this.mDeleteItem.step();
|
|
this.mDB.commitTransaction();
|
|
} catch (e) {
|
|
dump ("EXCEPTION; error is: " + this.mDB.lastErrorString + "\n");
|
|
dump (e);
|
|
this.mDB.rollbackTransaction();
|
|
}
|
|
|
|
this.mDeleteAttendees.reset();
|
|
this.mDeleteProperties.reset();
|
|
this.mDeleteRecurrence.reset();
|
|
this.mDeleteItem.reset();
|
|
|
|
delete this.mItemCache[aID];
|
|
},
|
|
}
|
|
|
|
|
|
/****
|
|
**** module registration
|
|
****/
|
|
|
|
var calStorageCalendarModule = {
|
|
mCID: Components.ID("{b3eaa1c4-5dfe-4c0a-b62a-b3a514218461}"),
|
|
mContractID: "@mozilla.org/calendar/calendar;1?type=storage",
|
|
|
|
registerSelf: function (compMgr, fileSpec, location, type) {
|
|
compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
|
|
compMgr.registerFactoryLocation(this.mCID,
|
|
"Calendar mozStorage/SQL back-end",
|
|
this.mContractID,
|
|
fileSpec,
|
|
location,
|
|
type);
|
|
},
|
|
|
|
getClassObject: function (compMgr, cid, iid) {
|
|
if (!cid.equals(this.mCID))
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
|
|
if (!iid.equals(Components.interfaces.nsIFactory))
|
|
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
if (!kStorageServiceIID)
|
|
throw Components.results.NS_ERROR_NOT_INITIALIZED;
|
|
|
|
return this.mFactory;
|
|
},
|
|
|
|
mFactory: {
|
|
createInstance: function (outer, iid) {
|
|
if (outer != null)
|
|
throw Components.results.NS_ERROR_NO_AGGREGATION;
|
|
return (new calStorageCalendar()).QueryInterface(iid);
|
|
}
|
|
},
|
|
|
|
canUnload: function(compMgr) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
function NSGetModule(compMgr, fileSpec) {
|
|
return calStorageCalendarModule;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// sqlTables generated from schema.sql via makejsschema.pl
|
|
//
|
|
|
|
var sqlTables = {
|
|
cal_calendars:
|
|
" id INTEGER PRIMARY KEY," +
|
|
" name STRING" +
|
|
"",
|
|
|
|
cal_items:
|
|
" cal_id INTEGER, " +
|
|
" item_type INTEGER," +
|
|
" id STRING," +
|
|
" time_created INTEGER," +
|
|
" last_modified INTEGER," +
|
|
" title STRING," +
|
|
" priority INTEGER," +
|
|
" privacy STRING," +
|
|
" ical_status STRING," +
|
|
" flags INTEGER," +
|
|
" event_start INTEGER," +
|
|
" event_end INTEGER," +
|
|
" event_stamp INTEGER," +
|
|
" todo_entry INTEGER," +
|
|
" todo_due INTEGER," +
|
|
" todo_completed INTEGER," +
|
|
" todo_complete INTEGER," +
|
|
" alarm_id INTEGER, " +
|
|
" recur_end INTEGER " +
|
|
"",
|
|
|
|
cal_attendees:
|
|
" item_id STRING," +
|
|
" attendee_id STRING," +
|
|
" common_name STRING," +
|
|
" rsvp INTEGER," +
|
|
" role STRING," +
|
|
" status STRING," +
|
|
" type STRING" +
|
|
"",
|
|
|
|
cal_alarms:
|
|
" id INTEGER PRIMARY KEY," +
|
|
" alarm_data BLOB" +
|
|
"",
|
|
|
|
cal_recurrence:
|
|
" item_id STRING," +
|
|
" recur_type INTEGER, " +
|
|
" count INTEGER," +
|
|
" interval INTEGER," +
|
|
" second STRING," +
|
|
" minute STRING," +
|
|
" hour STRING," +
|
|
" day STRING," +
|
|
" monthday STRING," +
|
|
" yearday STRING," +
|
|
" weekno STRING," +
|
|
" month STRING," +
|
|
" setpos STRING," +
|
|
" exceptions STRING" +
|
|
"",
|
|
|
|
cal_properties:
|
|
" item_id STRING," +
|
|
" key STRING," +
|
|
" value BLOB" +
|
|
"",
|
|
|
|
};
|