~kjyv/iphone-sync/main

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
 sync tomboy with ipod touch/iphone
 Copyright 2008 Stefan Bethge <stefan+sync at lanpartei.de>
 License: GPLv3 or higher
"""

#set your firmware version here like 114, 210, 220 ...
FW = 210

TMPFILE = '/tmp/notes.db'

if FW >= 200:
    PATH = '/var/mobile/Library/Notes/notes.db'
else:
    PATH = '/var/root/Library/Notes/notes.db'


GET_CMD = 'scp mobile@`cat /etc/default/ipod-convenience | grep IPADDRESS |\
        sed -n -r -e \'s/IPADDRESS=\"(.+)\"/\\1/p\'`:%s %s' % (PATH, TMPFILE)

PUT_CMD = 'scp %s mobile@`cat /etc/default/ipod-convenience | grep IPADDRESS |\
        sed -n -r -e \'s/IPADDRESS=\"(.+)\"/\\1/p\'`:%s' % (TMPFILE, PATH)


# pre 2.10 schema:
#CREATE TABLE Note (creation_date INTEGER, title TEXT, summary TEXT);
#CREATE TABLE note_bodies (note_id INTEGER, data, UNIQUE(note_id));
#CREATE TRIGGER delete_note_bodies AFTER DELETE ON Note
#BEGIN
#DELETE FROM note_bodies WHERE note_id = OLD.ROWID;
#END;

# after 2.10 schema:
#CREATE TABLE Note (ROWID INTEGER PRIMARY KEY, creation_date INTEGER, title TEXT, summary TEXT, contains_cjk INTEGER);
#CREATE TABLE _SqliteDatabaseProperties (key TEXT, value TEXT, UNIQUE(key));
#CREATE TABLE note_bodies (note_id INTEGER, data, UNIQUE(note_id));


try:
 	import pygtk
  	pygtk.require("2.0")
except:
  	pass
try:
	import gtk
  	import gtk.glade
except:
	sys.exit(1)

import sqlite3
import subprocess, sys, dbus, gobject, dbus.glib
import time, datetime
import re, os, sys
from gettext import lgettext as _

LEFT = 1
RIGHT = 2
DONT_SYNC = 3

class MainWindow:
    def __init__(self):
        self.processed_list = []
        self.process_cancelled = False
        self.gladefile = '%s/main_window.glade' % sys.path[0]
        self.wTree = gtk.glade.XML(self.gladefile)

        self.window = self.wTree.get_widget('main_window')
        
        if (self.window):
            self.window.connect('destroy', self.on_main_window_destroy)
        self.statusbar = self.wTree.get_widget('statusbar')

        self.sync_button = self.wTree.get_widget('sync_button')

        ## build treeviews
        self.ipod_list = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING)
        self.tomboy_list = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING)

        self.cNoteToggle = 0
        self.cNoteName = 1
        self.sNoteToggle = 'Sync'
        self.sNoteName = 'Name'

        self.ipod_treeview = self.wTree.get_widget('ipod_treeview')
        self.tomboy_treeview = self.wTree.get_widget('tomboy_treeview')

        self.add_treeview_column_toggle(self.sNoteToggle, self.cNoteToggle, self.tomboy_treeview, self.tomboy_list)
        self.add_treeview_column_text(self.sNoteName, self.cNoteName, self.tomboy_treeview)
        self.add_treeview_column_toggle(self.sNoteToggle, self.cNoteToggle, self.ipod_treeview, self.ipod_list)
        self.add_treeview_column_text(self.sNoteName, self.cNoteName, self.ipod_treeview)
        self.ipod_list.set_sort_column_id(self.cNoteName, gtk.SORT_ASCENDING)
        self.tomboy_list.set_sort_column_id(self.cNoteName, gtk.SORT_ASCENDING)
        self.ipod_treeview.set_model(self.ipod_list)
        self.tomboy_treeview.set_model(self.tomboy_list)

        #connect signals
        dic = { 'on_sync_button_clicked' : self.on_sync_button_clicked,
                'on_get_notes_button_clicked': self.on_get_notes_button_clicked,
                'on_select_all_button_clicked': self.on_select_all_button_clicked,
                'on_select_none_button_clicked': self.on_select_none_button_clicked,
                'on_select_all_ipod_button_clicked': self.on_select_all_ipod_button_clicked,
                'on_select_none_ipod_button_clicked': self.on_select_none_ipod_button_clicked,
                'on_select_all_tomboy_button_clicked': self.on_select_all_tomboy_button_clicked,
                'on_select_none_tomboy_button_clicked': self.on_select_none_tomboy_button_clicked,

                'on_menu_quit_activate': self.on_main_window_destroy,
                'on_menu_info_activate': self.on_menu_info_activate,
                
                'on_ipod_treeview_row_activated': self.on_ipod_treeview_row_activated,
                'on_tomboy_treeview_row_activated': self.on_tomboy_treeview_row_activated,

                'on_dont_sync_button_clicked': self.on_dont_sync_button_clicked,
                'on_use_left_button_clicked': self.on_use_left_button_clicked,
                'on_use_right_button_clicked': self.on_use_right_button_clicked,
                'on_cancel_button_clicked': self.on_cancel_button_clicked,

              }
        self.wTree.signal_autoconnect(dic)

        #other data holders
        self.last_conflict_left_text = ''
        self.last_conflict_right_text = ''

        #update lists at some point
        self.update_scheduled = False

    #helpers for adding columns
    def add_treeview_column_toggle(self, title, column_id, treeview, model):
        renderer = gtk.CellRendererToggle()
        renderer.set_property('activatable', True)
        renderer.connect("toggled", self.toggled_cb, (model, column_id))
        column = gtk.TreeViewColumn(title, renderer, active=column_id)
        column.set_resizable(True)		
        column.set_sort_column_id(column_id)
        treeview.append_column(column)

    def add_treeview_column_text(self, title, column_id, treeview):
        column = gtk.TreeViewColumn(title, gtk.CellRendererText(), text=column_id)
        column.set_resizable(True)		
        column.set_sort_column_id(column_id)
        treeview.append_column(column)

    def toggled_cb(self, cell, path, user_data):
        model, column_id = user_data
        model[path][column_id] = not model[path][column_id]

    #open note detail window
    def on_ipod_treeview_row_activated(self, widget, path, column):
        note_dlg = gtk.MessageDialog(type=gtk.MESSAGE_INFO,
		        message_format=self.get_ipod_note_body(self.ipod_list[path][1])['contents'],
                buttons=gtk.BUTTONS_OK)
        note_dlg.run()
        note_dlg.destroy()

    def on_tomboy_treeview_row_activated(self, widget, path, column):
        note_dlg = gtk.MessageDialog(type=gtk.MESSAGE_INFO,
	        message_format=self.get_tomboy_note_body(self.tomboy_list[path][1]),
		        buttons=gtk.BUTTONS_OK)
        note_dlg.run()
        note_dlg.destroy()
  
    #actually sync
    def on_sync_button_clicked(self, widget):
        self.process_ipod()
        self.process_tomboy()
        self.processed_list = []
        if not self.process_cancelled:
            context_id = self.statusbar.get_context_id('dbfilesstuff')
            self.statusbar.push(context_id, 'writing notes.db to ipod...')
            while gtk.events_pending(): gtk.main_iteration()
            subprocess.call(PUT_CMD, shell=True)
            self.statusbar.pop(context_id)
        else:
            #nothing should be synced since cancel was pressed
            self.process_cancelled = False

        if self.update_scheduled:
            self.update_lists()
            self.update_scheduled = False
    
    #collect notes from tomboy and ipod
    def on_get_notes_button_clicked(self, widget):
        context_id = self.statusbar.get_context_id('dbfilesstuff')
        self.statusbar.push(context_id, 'getting notes.db from ipod...')
        while gtk.events_pending(): gtk.main_iteration()

        global c, conn

        try:
            conn.close()
        except:
            pass

        subprocess.call(GET_CMD, shell=True)
        if not os.path.exists(TMPFILE):
            error_dlg = gtk.MessageDialog(type=gtk.MESSAGE_ERROR,
		            message_format=_('Can\'t open notes.db. Please ensure that you can connect to your iPod/iPhone using scp and that ipod-convenience is set up correctly.'),
                    buttons=gtk.BUTTONS_OK)
            error_dlg.run()
            error_dlg.destroy()
            return

        #(re)connect
        conn = sqlite3.connect(TMPFILE)
        c = conn.cursor()

        subprocess.call('cp %s %s.backup' % (TMPFILE, TMPFILE), shell=True)
        self.statusbar.pop(context_id)

        self.ipod_list.clear()
        self.tomboy_list.clear()

        self.get_ipod_notes()
        self.get_tomboy_notes()
        for note in self.ipod_notes:
            self.ipod_list.append((False, note['note_name']))
        
        for note in self.tomboy_notes:
            self.tomboy_list.append((False, note['note_name']))

        self.sync_button.set_sensitive(True)

    def on_select_all_button_clicked(self, widget):
        for note in self.tomboy_list:
            note[0] = True
        for note in self.ipod_list:
            note[0] = True

    def on_select_none_button_clicked(self, widget):
        for note in self.tomboy_list:
            note[0] = False
        for note in self.ipod_list:
            note[0] = False
    
    def on_select_all_ipod_button_clicked(self, widget):
        for note in self.ipod_list:
            note[0] = True
    
    def on_select_none_ipod_button_clicked(self, widget):
        for note in self.ipod_list:
            note[0] = False
    
    def on_select_all_tomboy_button_clicked(self, widget):
        for note in self.tomboy_list:
            note[0] = True
    
    def on_select_none_tomboy_button_clicked(self, widget):
        for note in self.tomboy_list:
            note[0] = False
    
    def on_main_window_destroy(self, widget):
        try:
            c.close()
            conn.close()
        except:
            pass
        gtk.main_quit()
    
    def on_menu_info_activate(self, widget):
        self.info_dialog = self.wTree.get_widget('info_dialog')
        self.info_dialog.run()
        self.info_dialog.hide()

    def show_conflict_dialog(self, note_left = '', note_right=''):
        self.conflict_dialog = self.wTree.get_widget('conflict_dialog')
        textview_left = self.wTree.get_widget('notes_textview_left')
        textview_right = self.wTree.get_widget('notes_textview_right')

        note_left_buffer = gtk.TextBuffer()
        note_left_buffer.set_text(self.escape_for_tomboy(note_left))
        textview_left.set_buffer(note_left_buffer)
        
        note_right_buffer = gtk.TextBuffer()
        note_right_buffer.set_text(self.escape_for_tomboy(note_right))
        textview_right.set_buffer(note_right_buffer)

        response = self.conflict_dialog.run()
        
        #save contents of text buffers
        self.last_conflict_left_text = note_left_buffer.get_text(*note_left_buffer.get_bounds())
        self.last_conflict_right_text = note_right_buffer.get_text(*note_right_buffer.get_bounds())
        self.conflict_dialog.hide()
        return response
    
    def on_use_left_button_clicked(self, widget):
        self.conflict_dialog.response(LEFT)
    
    def on_use_right_button_clicked(self, widget):
        self.conflict_dialog.response(RIGHT)

    def on_dont_sync_button_clicked(self, widget):
        self.conflict_dialog.response(DONT_SYNC)

    def on_cancel_button_clicked(self, widget):
        self.process_cancelled = True
        self.conflict_dialog.response(DONT_SYNC)

    def escape_for_ipod(self,note):
        return note.replace('<', '&lt;').replace('>', '&gt;').replace("\n","<br>")

    def escape_for_tomboy(self, note):
        return note.replace('<br>', '\n').replace('</div><div>', '\n').replace('<div>', '').replace('</div>', '').replace('<br class="webkit-block-placeholder">', '\n').replace('&amp;', '&')

    def get_ipod_notes(self):
        c.execute("SELECT title, creation_date, rowid from Note")
        notes = c.fetchall()
        
        self.ipod_notes = []
        for note in notes:
            self.ipod_notes.append({'note_name':note[0], 'change_date':note[1], 'contents':'', 'rowid':note[2]})

    def get_ipod_note_body(self, name_of_note):
        note = {}
        for n in self.ipod_notes:
            if n['note_name'] == name_of_note:
                note = n
                break
    
        try:
            #read note content from db
            c.execute("select data from note_bodies where note_id = ?", (note['rowid'],))
            for row in c:
                note_text = row[0]

            note['contents'] = self.escape_for_tomboy(note_text)
        except KeyError:
            pass

        return note

    def process_ipod(self):
        print "process tomboy"

        #walk the list of displayed rows and check if they are active
        for note_row in self.ipod_list:
            if self.process_cancelled:
                break

            if not note_row[0]:
                continue

            note_name = note_row[1]

            if not note_name in self.processed_list:
                self.processed_list.append(note_name)
            else:
                continue
            uri = tomboy.FindNote(note_name)
            ipod_note = self.get_ipod_note_body(note_name)

            if not tomboy.NoteExists(uri):
                uri = tomboy.CreateNamedNote(ipod_note['note_name'])
                tomboy.SetNoteContents(uri, ipod_note['contents'])
                tomboy.AddTagToNote(uri, "synced")
                print 'added new note %s to Tomboy' % ipod_note['note_name']
                self.update_scheduled = True

                ipod_time = (ipod_note['change_date'] + iphone_utc)-timezone

                #getting note's xml after creating doesn't work, if we don't sleep here for a while...
                #time.sleep(5)
                #xml = tomboy.GetNoteCompleteXml(uri)
                #change_date = datetime.datetime.fromtimestamp(ipod_time,tz=TZ()).isoformat()
                #xml = re.sub('<last-change-date>.+</last-change-date>', '<last-change-date>%s</last-change-date>' % change_date, xml)
                #xml = re.sub('<create-date>.+</create-date>', '<create-date>%s</create-date>' % change_date, xml)
                # it seems tomboy restores the last-change-date attribute upon setting the xml, so this approach does not work...
                # i'd like a tomboy.SetChangeDate(uri)
                #tomboy.SetNoteCompleteXml(uri, xml)

            else:
                tomboy_note = self.get_tomboy_note(note_name)
                #print self.last_conflict_right_text

                self.handle_conflict(tomboy_note, ipod_note)
                
                #stuff for automatic detection
                tomboy_time = tomboy.GetNoteChangeDate(uri)

                ipod_time = (ipod_note['change_date'] + iphone_utc)-timezone
                if tomboy_time > ipod_time:
                    print 'tomboy is newer'
                    #ask to update with tomboy note
                elif tomboy_time == ipod_time:
                    print 'same version'
                else:
                    print 'ipod is newer'
                    #ask to update tomboy note with the one from ipod

    def update_lists(self):
        self.ipod_list.clear()
        self.tomboy_list.clear()

        self.get_ipod_notes()
        self.get_tomboy_notes()
        for note in self.ipod_notes:
            self.ipod_list.append((False, note['note_name']))
        
        for note in self.tomboy_notes:
            self.tomboy_list.append((False, note['note_name']))

    #extra method for displaying notes
    def get_tomboy_note_body(self, note_name):
        uri = tomboy.FindNote(note_name)
        return tomboy.GetNoteContents(uri)

    #faster single notes when tomboy_notes is available
    def get_tomboy_note(self, note_name):
        for note in self.tomboy_notes:
            if note['note_name'] == note_name:
                return note
        return {}

    #get all notes from tomboy
    def get_tomboy_notes(self):
        self.tomboy_notes = []
        for note_uri in tomboy.ListAllNotes():
            self.tomboy_notes.append({'uri':note_uri,
                    'note_name':tomboy.GetNoteTitle(note_uri),
                    'change_date':tomboy.GetNoteChangeDate(note_uri),
                    'contents':tomboy.GetNoteContents(note_uri)})

    def create_note_on_ipod(self, note):
        ipod_time = (note['change_date']-iphone_utc)+timezone

        if FW >= 210:
            #get primary key for Notes
            c.execute('SELECT MAX(ROWID) + 1 FROM Note')
            max_rowid = c.fetchone()[0]

            c.execute('INSERT INTO Note VALUES (?,?,?,?, 0)',
                    (max_rowid, ipod_time, note['note_name'], note['note_name'][:30]))
        else:
            #don't need if for older versions
            c.execute('INSERT INTO Note VALUES (?,?, "")',
                            (ipod_time, note['note_name']))

        #get primary key for note_bodies
        c.execute('SELECT MAX(note_id) + 1 FROM note_bodies')
        max_note_id = c.fetchone()[0]

        note['contents'] = self.escape_for_ipod(note['contents'])

        c.execute("INSERT INTO note_bodies VALUES (?, ?)", (max_note_id,
                note['contents']))

        conn.commit()
        self.update_scheduled = True

    def update_note_in_tomboy(self, note):
        print 'updating note %s in tomboy with %s' % (note['note_name'], note['contents'][:30])
        uri = tomboy.FindNote(note['note_name'])
        
        note_text = self.escape_for_tomboy(note['contents'])
        tomboy.SetNoteContents(uri, note_text)

    def update_note_on_ipod(self, note):
        print 'updating note %s on ipod with %s' % (note['note_name'], note['contents'])
                    
        ipod_time = (note['change_date']-iphone_utc)+timezone

        c.execute('UPDATE Note SET creation_date = ? WHERE title = ?',
                        (ipod_time, note['note_name']))

        c.execute("UPDATE note_bodies SET data = ? WHERE note_id in (SELECT rowid FROM Note WHERE title = ?)", (self.escape_for_ipod(note['contents']), note['note_name']))

        conn.commit()

    def process_tomboy(self):
        print "process tomboy"
        note_from_ipod = None  #will be filled when note is on ipod
        def note_on_ipod(note_name):
            for note in self.ipod_list:
                if note_name == note[1]:
                    return True
            return False
                    
        for note in self.tomboy_list:
            if self.process_cancelled:
                break

            #don't process not activated rows
            if not note[0]:
                continue
           
            #skip already processed notes
            if not note[1] in self.processed_list:
                self.processed_list.append(note[1])
            else:
                continue
            
            note_from_tomboy = self.get_tomboy_note(note[1])
            note_from_ipod = self.get_ipod_note_body(note[1])

            if not note_on_ipod(note_from_tomboy['note_name']):
                print 'creating note %s on ipod' % note_from_tomboy['note_name']
                self.create_note_on_ipod(note_from_tomboy)
            else:
                #conflict
                self.handle_conflict(note_from_tomboy, note_from_ipod)

    def handle_conflict(self, note_from_tomboy, note_from_ipod):
            response = self.show_conflict_dialog(note_from_tomboy['contents'], note_from_ipod['contents'])
            if response == LEFT or response == RIGHT:
                if response == LEFT:
                    note_from_tomboy['contents'] = self.last_conflict_left_text
                    note_from_ipod['contents'] = self.last_conflict_left_text
                if response == RIGHT:
                    note_from_tomboy['contents'] = self.last_conflict_right_text
                    note_from_ipod['contents'] = self.last_conflict_right_text
                self.update_note_on_ipod(note_from_tomboy)
                self.update_note_in_tomboy(note_from_ipod)
            elif response == DONT_SYNC:
                pass

class TZ(datetime.tzinfo):
    def utcoffset(self,dt):
        timezone = get_timezone()
        return datetime.timedelta(seconds=-timezone)
    def dst(self, dt):
        if time.localtime(time.time()).tm_isdst:
            return datetime.timedelta(hours=1)
        else:
            return datetime.timedelta(0)

def get_timezone():
    if time.localtime(time.time()).tm_isdst: timezone = time.altzone
    else: timezone = time.timezone
    return timezone

if __name__ == "__main__":

    bus = dbus.SessionBus()
    obj = bus.get_object('org.gnome.Tomboy', '/org/gnome/Tomboy/RemoteControl')
    tomboy = dbus.Interface(obj, 'org.gnome.Tomboy.RemoteControl')

    c = None
    conn = None

    iphone_utc = int(time.mktime((2001,1,1,0,0,0,0,0,0)))
    timezone = get_timezone()

    mw = MainWindow()
    gtk.main()