def _update_object(self, uid, obj):
if self._delete_object(uid):
uid = self._create_object(obj)
return uid
else:
raise Exceptions.SyncronizeError(
"Error updating object (uid: %s)" % uid)
def _upload_photo(self, uploadInfo):
"""
Import a file into the f-spot catalog
"""
# Check if remote is read only
if self.photo_remote.IsReadOnly():
raise Exceptions.SyncronizeError(
_("F-Spot DBus interface is operating in read-only mode"))
# create roll if necessary
if not self.has_roll:
self.prepare_roll()
# start with enabled tags from gui, they exist in fspot for sure
tags = list(self.enabledTags)
# add tags from upload info
for tag in uploadInfo.tags:
self._create_tag(tag)
tags.append(tag)
# import the photo
try:
id = self.photo_remote.ImportPhoto(uploadInfo.url, True, tags)
return Rid(uid=str(id))
except:
raise Exceptions.SynchronizeError('Import Failed')
def _replace_photo(self, id, uploadInfo):
"""
Updates a photo (binary and metadata)
"""
try:
fotoId = self.zapi.update_photo(id, uploadInfo)
except Exception, e:
raise Exceptions.SyncronizeError("Zoto Update Error.")
def _upload_photo(self, uploadInfo):
"""
Upload to album
"""
try:
fotoId = self.zapi.add_to_album(uploadInfo, self.albumId)
except Exception, e:
raise Exceptions.SyncronizeError("Zoto Upload Error.")
def _update_note(self, uid, note):
log.debug("Updating note uid: %s" % uid)
if note.get_xml() != None:
ok = self.remoteTomboy.SetNoteCompleteXml(uid, note.get_xml())
else:
ok = self.remoteTomboy.SetNoteContents(uid, note.get_contents())
if not ok:
raise Exceptions.SyncronizeError(
"Error setting Tomboy note content (uri: %s)" % uid)
def _upload_photo(self, uploadInfo):
"""
Upload to album
"""
try:
ret = self.salbum.uploadPhoto(uploadInfo.url, uploadInfo.mimeType,
uploadInfo.name)
return Rid(ret.id)
except Exception, e:
raise Exceptions.SyncronizeError("Shutterfly Upload Error.")
def get(self, LUID):
for title in self._notes:
uid, timestamp, content = self._notes[title]
if uid == LUID:
n = Note.Note(
title=title,
#FIXME: Backpack doesnt have mtime, only creation time
modified=datetime.datetime.fromtimestamp(timestamp),
contents=content)
n.set_UID(LUID)
return n
raise Exceptions.SyncronizeError("Could not find note %s" % LUID)
def _upload_photo(self, uploadInfo):
"""
Upload to album; and return image id here
"""
try:
rsp = self.fapi.photos.upload(uploadInfo.url,
aid=self.albums.get(
self.albumname, None))
pid = str(rsp["pid"])
return Rid(uid=pid)
except pyfacebook.FacebookError, f:
raise Exceptions.SyncronizeError("Facebook Upload Error %s" % f)
def _create_object(self, note):
obj = evolution.ecal.ECalComponent(
evolution.ecal.CAL_COMPONENT_JOURNAL)
obj.set_summary(note.title)
if note.contents != None:
obj.set_description(note.contents)
uid = self.memos.add_object(obj)
if uid != None:
mtime = datetime.datetime.fromtimestamp(obj.get_modified())
note = self._get_object(uid)
return note.get_rid()
else:
raise Exceptions.SyncronizeError("Error creating memo")
def put(self, data, overwrite, LUID=None):
DataProvider.DataSink.put(self, data, overwrite, LUID)
if self.slow:
time.sleep(1)
if self.count >= self.errorAfter:
if self.errorFatal:
raise Exceptions.SyncronizeFatalError(
"Error After:%s Count:%s" % (self.errorAfter, self.count))
else:
raise Exceptions.SyncronizeError("Error After:%s Count:%s" %
(self.errorAfter, self.count))
self.count += 1
newData = TestDataType(data.get_UID())
return newData.get_rid()
def delete(self, LUID):
"""
Delete a photo by ID
"""
if not self.sphotos.has_key(LUID):
log.warn("Photo does not exist")
return
try:
self.zapi.delete_from_album(LUID, self.albumId)
del self.sphotos[LUID]
except xmlrpclib.Fault, e:
raise Exceptions.SyncronizeError("Zoto Delete Error: " +
e.faultString)
def _create_object(self, event):
# work around.. (avoid duplicate UIDs)
if "UID" in [x.name for x in list(event.iCal.lines())]:
event.iCal.remove(event.iCal.uid)
obj = evolution.ecal.ECalComponent(evolution.ecal.CAL_COMPONENT_TODO,
event.get_ical_string())
if self.tasks.add_object(obj):
mtime = datetime.datetime.fromtimestamp(obj.get_modified())
return conduit.datatypes.Rid(uid=obj.get_uid(),
mtime=mtime,
hash=mtime)
else:
raise Exceptions.SyncronizeError("Error creating event")
def delete(self, LUID):
"""
Delete a photo by ID
Deleting a photo invalidates album length and photo index values.
We must reload the photos (or do something else...)
"""
if not self.sphotos.has_key(LUID):
log.warn("Photo does not exist")
return
try:
self.salbum.deletePhoto(self.sphotos[LUID])
except Exception, e:
raise Exceptions.SyncronizeError(
"Shutterfly Delete Error - Try Again.")
def put(self, photo, overwrite, LUID=None):
"""
Accepts a vfs file. Must be made local.
I also store a md5 of the photos uri to check for duplicates
"""
DataProvider.DataSink.put(self, photo, overwrite, LUID)
originalName = photo.get_filename()
#Gets the local URI (/foo/bar). If this is a remote file then
#it is first transferred to the local filesystem
photoURI = photo.get_local_uri()
mimeType = photo.get_mimetype()
tags = photo.get_tags()
caption = photo.get_caption()
uploadInfo = UploadInfo(photoURI, mimeType, originalName, tags,
caption)
if overwrite and LUID:
rid = self._replace_photo(LUID, uploadInfo)
else:
if LUID and self._get_photo_info(LUID):
remotePhoto = self.get(LUID)
comp = photo.compare(remotePhoto, False)
log.debug(
"Compared %s with %s. Result = %s" %
(photo.get_filename(), remotePhoto.get_filename(), comp))
if LUID != None and comp == conduit.datatypes.COMPARISON_NEWER:
rid = self._replace_photo(LUID, uploadInfo)
elif comp == conduit.datatypes.COMPARISON_EQUAL:
rid = remotePhoto.get_rid()
else:
raise Exceptions.SynchronizeConflictError(
comp, photo, remotePhoto)
else:
log.debug(
"Uploading Photo URI = %s, Mimetype = %s, Original Name = %s"
% (photoURI, mimeType, originalName))
rid = self._upload_photo(uploadInfo)
if not rid:
raise Exceptions.SyncronizeError("Error putting/updating photo")
else:
return rid
def put(self, note, overwrite, LUID=None):
DataProvider.DataSink.put(self, note, overwrite, LUID)
#If all that went well then actually store some notes.
uid = None
try:
if note.title in self._notes:
log.debug("Updating Existing")
uid, oldtimestamp, oldcontent = self._notes[note.title]
self.ba.notes.update(self.pageID, uid, note.title,
note.contents)
else:
log.debug("Creating New (title: %s)" % note.title)
uid, title, timestamp, content = self.ba.notes.create(
self.pageID, note.title, note.contents)
self._notes[title] = (uid, timestamp, content)
except backpack.BackpackError, err:
raise Exceptions.SyncronizeError("Could not sync note (%s)" % err)
def refresh(self):
DataProvider.DataSource.refresh(self)
# sqlite3 is not thread safe, so we cannot preserve connections in this class
con = sqlite3.connect(
os.path.join(FFDIR, self.profilepath, "places.sqlite"))
try:
# table structure
# moz_bookmarks: id|type|fk|parent|position|title|keyword_id|folder_type|dateAdded|lastModified
# moz_places: id|url|title|rev_host|visit_count|hidden|typed|favicon_id|frecency
cur = con.execute(
"SELECT b.title,p.url FROM moz_bookmarks b, moz_places p WHERE b.fk=p.id;"
)
except:
con.close()
raise Exceptions.SyncronizeError(
"Can't read Firefox 3 Bookmarks - Make sure Firefox is closed."
)
for (title, url) in cur.fetchall():
bookmark = Bookmark.Bookmark(title, url)
bookmark.set_UID(bookmark.get_hash())
self._bookmarks.append(bookmark)
con.close()
def get(self, LUID):
DataProvider.DataSource.get(self, LUID)
if self.slow:
time.sleep(1)
index = int(LUID)
if index >= self.errorAfter:
if self.errorFatal:
raise Exceptions.SyncronizeFatalError(
"Error After:%s Count:%s" % (self.errorAfter, index))
else:
raise Exceptions.SyncronizeError("Error After:%s Count:%s" %
(self.errorAfter, index))
mtime = DEFAULT_MTIME
if self.newMtime:
mtime = datetime.datetime.now()
hash = DEFAULT_HASH
if self.newHash:
hash = Utils.random_string()
data = TestDataType(LUID, mtime, hash)
return data
def _create_object(self, contact):
obj = evolution.ebook.EContact(vcard=contact.get_vcard_string())
if self.book.add_contact(obj):
return self._get_object(obj.get_uid()).get_rid()
else:
raise Exceptions.SyncronizeError("Error creating contact")
