code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Plugins/Extensions/HbbTV/bookmark.py

   1 class BookmarkData:
   2         def __init__(self, _id, _title, _url, _parent):
   3                 self.mId        = _id
   4                 self.mTitle     = _title
   5                 self.mUrl       = _url
   6                 self.mParent    = _parent
   7         def dump(self, _intent='  '):
   8                 print "%s-> %d, %s, %s, %d" % (_intent, self.mId, self.mTitle, self.mUrl, self.mParent)
   9
  10 class CategoryData:
  11         def __init__(self, _id, _name):
  12                 self.mId        = _id
  13                 self.mName      = _name
  14                 self.mBookmarks = {}
  15
  16         def setBookmarks(self, _bookmarks):
  17                 self.mBookmarks = _bookmarks
  18
  19         def appendBookmark(self, _bookmark):
  20                 self.mBookmarks[_bookmark.mId] = _bookmark
  21
  22         def dump(self):
  23                 print "  -> %d, %s" % (self.mId, self.mName)
  24                 for key in self.mBookmarks.iterkeys():
  25                         self.mBookmarks[key].dump('      ')
  26
  27 import ConfigParser
  28 class SimpleConfigParser:
  29         def __init__(self):
  30                 self.mFileName = None
  31                 self.mConfig = None
  32                 self.mCategoryCurrentIdx = 0
  33                 self.mBookmarkCurrentIdx = 0
  34                 self.mDataValid = False
  35                 self.mPopulateValid = False
  36
  37         def _read(self):
  38                 if self.mDataValid:
  39                         return
  40                 print "populate!!"
  41                 self.mConfig.read(self.mFileName)
  42
  43                 self.mCategoryCurrentIdx = self.getNumber('__SYS__', 'category_current_idx')
  44                 self.mBookmarkCurrentIdx = self.getNumber('__SYS__', 'bookmark_current_idx')
  45                 self.mDataValid = True
  46
  47         def _save(self):
  48                 with open(self.mFileName, 'wb') as bookmarkFile:
  49                         self.mConfig.write(bookmarkFile)
  50                 self.mDataValid = False
  51                 self.mPopulateValid = False
  52
  53         def _del(self, _section, _option=None):
  54                 #print _section, ' :', _option
  55                 if _option is None:
  56                         if not self.exist(_section):
  57                                 return
  58                         self.mConfig.remove_section(_section)
  59                         return
  60                 if not self.exist(_section, _option):
  61                         return
  62                 self.mConfig.remove_option(_section, _option)
  63
  64         def _get(self, _section, _option, _default):
  65                 try:
  66                         data = self.mConfig.get(_section, _option)
  67                 except Exception, e:
  68                         #print e
  69                         return _default
  70                 else :  return data
  71
  72         def _set(self, _section, _option, _value):
  73                 self.mConfig.set(_section, _option, _value)
  74
  75         def exist(self, _section, _option=None):
  76                 if _option is None:
  77                         return self.mConfig.has_section(_section)
  78                 return self.mConfig.has_option(_section, _option)
  79
  80         def setNumber(self, _section, _option, _value):
  81                 self._set(_section, _option, str(_value))
  82
  83         def setString(self, _section, _option, _value):
  84                 self._set(_section, _option, _value)
  85
  86         def getNumber(self, _section, _option, _default=0):
  87                 return int(self._get(_section, _option, _default))
  88
  89         def getString(self, _section, _option, _default=''):
  90                 return self._get(_section, _option, _default)
  91
  92         def delOption(self, _section, _option):
  93                 self._del(_section, _option)
  94
  95         def addSection(self, _section):
  96                 self.mConfig.add_section(_section)
  97
  98         def delSection(self, _section):
  99                 self._del(_section)
 100
 101         def init(self, _fileName):
 102                 self.mFileName = _fileName
 103                 self.mConfig = ConfigParser.RawConfigParser()
 104                 if self.mConfig is None:
 105                         return False
 106                 self._read()
 107                 return True
 108
 109 class BookmarkManager(SimpleConfigParser):
 110         _instance = None
 111         def __new__(cls, *args, **kwargs):
 112             if not cls._instance:
 113                 cls._instance = super(Singleton, cls).__new__(
 114                                    cls, *args, **kwargs)
 115             return cls._instance
 116
 117         def __init__(self, _dbFileName):
 118                 SimpleConfigParser.__init__(self)
 119
 120                 self.mBookmarkRoot = None
 121                 self.mDebugEnable = False
 122
 123                 import os
 124                 if not os.path.exists(_dbFileName):
 125                         os.system('echo "[__SYS__]" > %s'%(_dbFileName))
 126                         os.system('echo "category_current_idx = 1" >> %s'%(_dbFileName))
 127                         os.system('echo "bookmark_current_idx = 1" >> %s'%(_dbFileName))
 128                         os.system('echo "[c-1]" >> %s'%(_dbFileName))
 129                         os.system('echo "id = 1" >> %s'%(_dbFileName))
 130                         os.system('echo "name = My favorite" >> %s'%(_dbFileName))
 131                         os.system('echo "[b-1]" >> %s'%(_dbFileName))
 132                         os.system('echo "url = http://www2.vuplus.com/" >> %s'%(_dbFileName))
 133                         os.system('echo "id = 1" >> %s'%(_dbFileName))
 134                         os.system('echo "parent = 1" >> %s'%(_dbFileName))
 135                         os.system('echo "title = Vuplus Home" >> %s'%(_dbFileName))
 136
 137                 self.init(_dbFileName)
 138
 139         def message(self, format, params=None):
 140                 if not self.mDebugEnable:
 141                         return
 142                 if params is None:
 143                         print format
 144                 else:   print format % (params)
 145
 146         def getBookmark(self, _title):
 147                 self.populate()
 148                 for key in self.mBookmarkRoot.iterkeys():
 149                         for key2 in self.mBookmarkRoot[key].mBookmarks.iterkeys():
 150                                 if self.mBookmarkRoot[key].mBookmarks[key2].mTitle == _title:
 151                                         return 'b-%d' % (self.mBookmarkRoot[key].mBookmarks[key2].mId)
 152                 return None
 153
 154         def addBookmark(self, _title, _url, _parent):
 155                 if self.getBookmark(_title) is not None:
 156                         return False
 157                 i = self.mBookmarkCurrentIdx + 1
 158                 s = "b-%d" % (i,)
 159                 self.message("add bookmark : %s, %s, %d", (_title, _url, _parent,))
 160
 161                 self.mConfig.add_section(s)
 162                 self.setNumber(s, 'id', i)
 163                 self.setString(s, 'title', _title)
 164                 self.setString(s, 'url', _url)
 165                 self.setNumber(s, 'parent', _parent)
 166                 self.setNumber('__SYS__', 'bookmark_current_idx', i)
 167                 self._save()
 168
 169                 return True
 170
 171         def deleteBookmark(self, _id):
 172                 self.populate()
 173                 self.message("delete bookmark : %d", (_id,))
 174                 self.delSection('b-%d' % (_id,))
 175                 self._save()
 176
 177         def updateBookmark(self, _bookmark):
 178                 self.populate()
 179                 s = "b-%d" % (_bookmark.mId)
 180                 self.message("update bookmark : %s, %s, %d", (_bookmark.mTitle, _bookmark.mUrl, _bookmark.mParent,))
 181                 self.setString(s, 'title', _bookmark.mTitle)
 182                 self.setString(s, 'url', _bookmark.mUrl)
 183                 self.setNumber(s, 'parent', _bookmark.mParent)
 184                 self._save()
 185
 186         def getCategory(self, _name):
 187                 self.populate()
 188                 for key in self.mBookmarkRoot.iterkeys():
 189                         if self.mBookmarkRoot[key].mName == _name:
 190                                 return 'c-%d' % (self.mBookmarkRoot[key].mId)
 191                 return None
 192
 193         def addCategory(self, _name):
 194                 if self.getCategory(_name) is not None:
 195                         return False
 196                 self.message("add category : %s", (_name,))
 197                 i = self.mCategoryCurrentIdx + 1
 198                 s = "c-%d" % (i)
 199
 200                 self.mConfig.add_section(s)
 201                 self.setNumber(s, 'id', i)
 202                 self.setNumber(s, 'name', _name)
 203                 self.setNumber('__SYS__', 'category_current_idx', i)
 204                 self._save()
 205
 206                 return True
 207
 208         def deleteCategory(self, _id):
 209                 self.populate()
 210                 self.message("delete category : %d", (_id,))
 211                 try:
 212                         for key in self.mBookmarkRoot[_id].mBookmarks.iterkeys():
 213                                 self.delSection('b-%d' % (key,))
 214                 except: pass
 215                 self.delSection('c-%d' % (_id,))
 216                 self._save()
 217
 218         def updateCategory(self, _category):
 219                 self.populate()
 220                 self.message("update category : %s", (_category.mName,))
 221                 s = "c-%d" % (_category.mId)
 222                 self.setNumber(s, 'name', _category.mName)
 223                 self._save()
 224
 225         def populate(self):
 226                 cx, bx = 0, 0
 227                 categoryList = {}
 228                 self.message("populate : %d, %d", (self.mPopulateValid, self.mDataValid))
 229
 230                 self._read()
 231                 if self.mPopulateValid:
 232                         return
 233
 234                 while cx <= self.mCategoryCurrentIdx:
 235                         s = 'c-%d' % (cx,)
 236                         i = self.getNumber(s, 'id', -1)
 237                         if i != -1:
 238                                 n = self.getString(s, 'name')
 239                                 categoryList[i] = CategoryData(i, n)
 240                         cx += 1
 241                 sorted(categoryList)
 242                 while bx <= self.mBookmarkCurrentIdx:
 243                         s = 'b-%d' % (bx,)
 244                         i = self.getNumber(s, 'id', -1)
 245                         if i != -1:
 246                                 t = self.getString(s, 'title')
 247                                 u = self.getString(s, 'url')
 248                                 p = self.getNumber(s, 'parent')
 249                                 try:
 250                                         categoryList[p].appendBookmark(BookmarkData(i, t, u, p))
 251                                 except Exception, e: self._del(s)
 252                         bx += 1
 253                 for key in categoryList.iterkeys():
 254                         sorted(categoryList[key].mBookmarks)
 255                 self.mBookmarkRoot = categoryList
 256                 self.mPopulateValid = True
 257                 self.dump()
 258
 259         def getBookmarkRoot(self):
 260                 self.populate()
 261                 return self.mBookmarkRoot
 262
 263         def dump(self):
 264                 if not self.mDebugEnable:
 265                         return
 266                 self.populate()
 267                 print "-- snapshot --"
 268                 for key in self.mBookmarkRoot.iterkeys():
 269                         self.mBookmarkRoot[key].dump()
 270                 print "--------------"
 271
 272         @staticmethod
 273         def getInstance():
 274                 return BookmarkManager('/usr/lib/enigma2/python/Plugins/Extensions/HbbTV/bookmark.ini')
 275
 276