root/storage/bookmarks_store.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys, string, xml.dom.minidom, os
try:
        import gtk
        import gobject
except:
        sys.exit(1)

# this class represent the whole bookmarks list
class bookmarks_store :
        
        # bts_name is a string arg. It will be used to have
        # differents bookmarks for differents protocols.
        def __init__(self, bts_name, listing) :
                self.bmark_file ="bookmarks_%s.xml" %(bts_name)
                #listing is : Title of the bookmarks, description of the search
                # search method :
                # 1- bug number
                # 2- simple search
                # 3- package search
                # 4- advanced search
                
                self.listing = listing
                self.bts_name = bts_name
                self.root = listing.append(None, (bts_name, "", bts_name))
                
                # rows-reordered signal not sent
                # but I let this code here, don't know why.
                def reorder_callback(treemodel, path, itera, new_order):
                        self.sync_file()
                # Funny ! rows-reordered is not sent but we can
                # use the rows-deleted signal as well.
                def deleted_callback(treemodel, path):
                        self.sync_file()
                self.listing.connect("rows-reordered", reorder_callback)
                self.listing.connect("row-deleted", deleted_callback)
                
                if os.path.exists(self.bmark_file) :
                        if self.import_file(self.bmark_file) == 0 :
                                print "Bookmarks not in a valid format."
                                print "Please remove the %s file" %self.bmark_file
                else :
                        doc = xml.dom.minidom.Document()
                        store = doc.createElement("store")
                        doc.appendChild(store)
                        #here we can put hardcoded default
                        #
                        #then we create the file
                        f = open(self.bmark_file, mode='a+')
                        f.write(doc.toxml().encode("utf-8"))
                        f.close()
        
        def import_file(self,zefile) :
                #programmation défensive needed ici !!!
                # !!!!!!!!
                f = open(zefile,mode='r')
                # sanitize the pretty XML
                stringed = f.read().replace('\n','').replace('\t','')
                try :
                        doc = xml.dom.minidom.parseString(stringed)
                except :
                        return 0
                for bmark in doc.getElementsByTagName("bookmark") :
                        title = bmark.getAttribute("title")
                        self.listing.insert_before(self.root, None, (title, bmark.toxml(), self.bts_name))
                return 1
        
        def open_file(self,zefile) :
                #programmation défensive needed ici !!!
                # !!!!!!!!
                array=[]
                f = open(zefile,mode='r')
                # sanitize the pretty XML
                stringed = f.read().replace('\n','').replace('\t','')
                try :
                        doc = xml.dom.minidom.parseString(stringed)
                except :
                        return array
                for bmark in doc.getElementsByTagName("bookmark") :
                        array.append(bmark.toxml())
                return array

        def add(self,args) :
                #do not forget to also add the bookmarks to
                #the stored bookmarks. (sync with storage)
                doc2 = xml.dom.minidom.parseString(args)
                bmark = doc2.getElementsByTagName("bookmark")[0]
                title = bmark.getAttribute("title")
                self.listing.insert_before(self.root, None, (title, args, self.bts_name))
                self.sync_file()

        def delete(self, to_delete) :
                #do not forget to also remove the bookmarks from
                #the stored bookmarks. (sync with storage)
                if self._is_bookmark(to_delete):
                        self.listing.remove(to_delete)
                        self.sync_file()
        
        def rename(self, to_rename, new_name) :
                if self._is_bookmark(to_delete):
                        self.listing[to_rename][0]=new_name
                        self.sync_file()
        
        def _is_bookmark(self, iter):
                return self.listing.get_value(iter, 1)

        def sync_file(self) :
                doc = xml.dom.minidom.Document()
                store = doc.createElement("store")
                doc.appendChild(store)
                for i in self.listing[self.listing.get_path(self.root)].iterchildren() :
                        doc2 = xml.dom.minidom.parseString(i[1])
                        bmark = doc2.getElementsByTagName("bookmark")[0]
                        bmark.setAttribute("title",i[0].strip())
                        store.appendChild(bmark)
                #it's maybe not optimal to open/close the file each time we sync
                # but I'm not sure that those operations are so frequent
                # might be changed in the future.
                f = open(self.bmark_file, mode='w+')
                f.write(doc.toprettyxml().encode("utf-8"))
                f.close()

# this is a lonely bookmark in the store
class bookmark : 
        # constructor take the path to the bug in the store.
        def __init__(self,path,descr,bts) :
                zbug = 0
                zsearch = ''
                zproduct = ''
                ztitle = ''
                if path != None :
                        zetuple = path.get_selection().get_selected()
                        #cursor = path.get_cursor()
                        #print zetuple
                        #print cursor
                        string = zetuple[0].get_value(zetuple[1],1)
                else :
                        string = descr
                doc2 = xml.dom.minidom.parseString(string)
                bmark = doc2.getElementsByTagName("bookmark")[0]
                zmethod =  int(bmark.getAttribute("type"))
                if zmethod == 1:
                        # besoin de programmation défensive ici FIXME
                        #bug = int(zetuple[0].get_value(zetuple[1],2))
                        element = bmark.getElementsByTagName("bug")[0]
                        zbug = int(element.childNodes[0].nodeValue)
                elif zmethod == 2:
                        s_element = bmark.getElementsByTagName("search")[0]
                        zsearch = s_element.childNodes[0].nodeValue
                elif zmethod == 3:
                        s_element = bmark.getElementsByTagName("search")
                        p_element = bmark.getElementsByTagName("product")[0]
                        zproduct = p_element.childNodes[0].nodeValue
                        if len(s_element) == 0 :
                                zsearch = None
                        else :  
                                zsearch = s_element[0].childNodes[0].nodeValue
                self.bug = str(zbug)
                self.method = zmethod
                self.search = zsearch
                self.product = zproduct
                self.title = bmark.getAttribute("title")
                self.bts = bts

        def get_method(self) :
                return self.method

        def get_bug(self) :
                return self.bug

        def get_search(self) :
                return self.search

        def get_product(self) :
                return self.product

        def get_title(self) :
                return self.title