git.maemo.org Git - doneit/blob - src/rtm_view.py

   1 """
   2 @todo Add an agenda view to the task list
   3         Tree of days, with each successive 7 days dropping the visibility of further lower priority items
   4 """
   5
   6 import webbrowser
   7 import datetime
   8 import urlparse
   9 import base64
  10
  11 import gobject
  12 import gtk
  13
  14 import toolbox
  15 import gtk_toolbox
  16 import rtm_backend
  17 import rtm_api
  18
  19
  20 def abbreviate(text, expectedLen):
  21         singleLine = " ".join(text.split("\n"))
  22         lineLen = len(singleLine)
  23         if lineLen <= expectedLen:
  24                 return singleLine
  25
  26         abbrev = "..."
  27
  28         leftLen = expectedLen // 2 - 1
  29         rightLen = max(expectedLen - leftLen - len(abbrev) + 1, 1)
  30
  31         abbrevText =  singleLine[0:leftLen] + abbrev + singleLine[-rightLen:-1]
  32         assert len(abbrevText) <= expectedLen, "Too long: '%s'" % abbrevText
  33         return abbrevText
  34
  35
  36 def abbreviate_url(url, domainLength, pathLength):
  37         urlParts = urlparse.urlparse(url)
  38
  39         netloc = urlParts.netloc
  40         path = urlParts.path
  41
  42         pathLength += max(domainLength - len(netloc), 0)
  43         domainLength += max(pathLength - len(path), 0)
  44
  45         netloc = abbreviate(netloc, domainLength)
  46         path = abbreviate(path, pathLength)
  47         return netloc + path
  48
  49
  50 def get_token(username, apiKey, secret):
  51         token = None
  52         rtm = rtm_api.RTMapi(username, apiKey, secret, token)
  53
  54         authURL = rtm.getAuthURL()
  55         webbrowser.open(authURL)
  56         mb = gtk_toolbox.MessageBox2("You need to authorize DoneIt with\nRemember The Milk.\nClick OK after you authorize.")
  57         mb.run()
  58
  59         token = rtm.getToken()
  60         return token
  61
  62
  63 def get_credentials(credentialsDialog):
  64         username, password = credentialsDialog.request_credentials()
  65         token = get_token(username, rtm_backend.RtMilkManager.API_KEY, rtm_backend.RtMilkManager.SECRET)
  66         return username, password, token
  67
  68
  69 def item_sort_by_priority_then_date(items):
  70         sortedTasks = list(items)
  71         sortedTasks.sort(
  72                 key = lambda taskDetails: (
  73                         taskDetails["priority"].get_nothrow(4),
  74                         taskDetails["dueDate"].get_nothrow(datetime.datetime.max),
  75                 ),
  76         )
  77         return sortedTasks
  78
  79
  80 def item_sort_by_date_then_priority(items):
  81         sortedTasks = list(items)
  82         sortedTasks.sort(
  83                 key = lambda taskDetails: (
  84                         taskDetails["dueDate"].get_nothrow(datetime.datetime.max),
  85                         taskDetails["priority"].get_nothrow(4),
  86                 ),
  87         )
  88         return sortedTasks
  89
  90
  91 def item_in_agenda(item):
  92         taskDate = item["dueDate"].get_nothrow(datetime.datetime.max)
  93         today = datetime.datetime.now()
  94         delta = taskDate - today
  95         dayDelta = abs(delta.days)
  96
  97         priority = item["priority"].get_nothrow(4)
  98         weeksVisible = 5 - priority
  99
 100         isVisible = not bool(dayDelta / (weeksVisible * 7))
 101         return isVisible
 102
 103
 104 def item_sort_by_fuzzydate_then_priority(items):
 105         sortedTasks = list(items)
 106
 107         def advanced_key(taskDetails):
 108                 dueDate = taskDetails["dueDate"].get_nothrow(datetime.datetime.max)
 109                 priority = taskDetails["priority"].get_nothrow(4)
 110                 isNotSameYear = not toolbox.is_same_year(dueDate)
 111                 isNotSameMonth = not toolbox.is_same_month(dueDate)
 112                 isNotSameDay = not toolbox.is_same_day(dueDate)
 113                 return isNotSameDay, isNotSameMonth, isNotSameYear, priority, dueDate
 114
 115         sortedTasks.sort(key=advanced_key)
 116         return sortedTasks
 117
 118
 119 class ItemListView(object):
 120
 121         ID_IDX = 0
 122         COMPLETION_IDX = 1
 123         NAME_IDX = 2
 124         PRIORITY_IDX = 3
 125         DUE_IDX = 4
 126         FUZZY_IDX = 5
 127         LINK_IDX = 6
 128         NOTES_IDX = 7
 129
 130         def __init__(self, widgetTree):
 131                 self._manager = None
 132                 self._projId = None
 133                 self._showCompleted = False
 134                 self._showIncomplete = True
 135
 136                 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
 137
 138                 self._itemList = gtk.ListStore(
 139                         gobject.TYPE_STRING, # id
 140                         gobject.TYPE_BOOLEAN, # is complete
 141                         gobject.TYPE_STRING, # name
 142                         gobject.TYPE_STRING, # priority
 143                         gobject.TYPE_STRING, # due
 144                         gobject.TYPE_STRING, # fuzzy due
 145                         gobject.TYPE_STRING, # Link
 146                         gobject.TYPE_STRING, # Notes
 147                 )
 148                 self._completionColumn = gtk.TreeViewColumn('') # Complete?
 149                 self._completionCell = gtk.CellRendererToggle()
 150                 self._completionCell.set_property("activatable", True)
 151                 self._completionCell.connect("toggled", self._on_completion_change)
 152                 self._completionColumn.pack_start(self._completionCell, False)
 153                 self._completionColumn.set_attributes(self._completionCell, active=self.COMPLETION_IDX)
 154                 self._priorityColumn = gtk.TreeViewColumn('') # Priority
 155                 self._priorityCell = gtk.CellRendererText()
 156                 self._priorityColumn.pack_start(self._priorityCell, False)
 157                 self._priorityColumn.set_attributes(self._priorityCell, text=self.PRIORITY_IDX)
 158                 self._nameColumn = gtk.TreeViewColumn('Name')
 159                 self._nameCell = gtk.CellRendererText()
 160                 self._nameColumn.pack_start(self._nameCell, True)
 161                 self._nameColumn.set_attributes(self._nameCell, text=self.NAME_IDX)
 162                 self._dueColumn = gtk.TreeViewColumn('Due')
 163                 self._dueCell = gtk.CellRendererText()
 164                 self._dueColumn.pack_start(self._nameCell, False)
 165                 self._dueColumn.set_attributes(self._nameCell, text=self.FUZZY_IDX)
 166                 self._linkColumn = gtk.TreeViewColumn('') # Link
 167                 self._linkCell = gtk.CellRendererText()
 168                 self._linkColumn.pack_start(self._nameCell, False)
 169                 self._linkColumn.set_attributes(self._nameCell, text=self.LINK_IDX)
 170                 self._notesColumn = gtk.TreeViewColumn('') # Notes
 171                 self._notesCell = gtk.CellRendererText()
 172                 self._notesColumn.pack_start(self._nameCell, False)
 173                 self._notesColumn.set_attributes(self._nameCell, text=self.NOTES_IDX)
 174
 175                 self._todoBox = widgetTree.get_widget("todoBox")
 176                 self._todoItemScroll = gtk.ScrolledWindow()
 177                 self._todoItemScroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 178                 self._todoItemTree = gtk.TreeView()
 179                 self._todoItemScroll.add(self._todoItemTree)
 180                 self._onItemSelectId = 0
 181
 182
 183         def enable(self, manager, projId):
 184                 self._manager = manager
 185                 self._projId = projId
 186
 187                 self._todoBox.pack_start(self._todoItemScroll)
 188                 self._todoItemScroll.show_all()
 189
 190                 self._itemList.clear()
 191                 self._todoItemTree.append_column(self._completionColumn)
 192                 self._todoItemTree.append_column(self._priorityColumn)
 193                 self._todoItemTree.append_column(self._nameColumn)
 194                 self._todoItemTree.append_column(self._dueColumn)
 195                 self._todoItemTree.append_column(self._linkColumn)
 196                 self._todoItemTree.append_column(self._notesColumn)
 197                 self.reset_task_list(self._projId)
 198
 199                 self._todoItemTree.set_headers_visible(False)
 200                 self._nameColumn.set_expand(True)
 201
 202                 self._onItemSelectId = self._todoItemTree.connect("row-activated", self._on_item_select)
 203
 204         def disable(self):
 205                 self._manager = None
 206                 self._projId = None
 207
 208                 self._todoBox.remove(self._todoItemScroll)
 209                 self._todoItemScroll.hide_all()
 210                 self._todoItemTree.disconnect(self._onItemSelectId)
 211
 212                 self._todoItemTree.remove_column(self._completionColumn)
 213                 self._todoItemTree.remove_column(self._priorityColumn)
 214                 self._todoItemTree.remove_column(self._nameColumn)
 215                 self._todoItemTree.remove_column(self._dueColumn)
 216                 self._todoItemTree.remove_column(self._linkColumn)
 217                 self._todoItemTree.remove_column(self._notesColumn)
 218                 self._itemList.clear()
 219                 self._itemList.set_model(None)
 220
 221         def reset_task_list(self, projId):
 222                 self._projId = projId
 223                 self._itemList.clear()
 224                 self._populate_items()
 225
 226         def _populate_items(self):
 227                 projId = self._projId
 228                 rawTasks = self._manager.get_tasks_with_details(projId)
 229                 filteredTasks = (
 230                         taskDetails
 231                         for taskDetails in rawTasks
 232                                 if self._showCompleted and taskDetails["isCompleted"] or self._showIncomplete and not taskDetails["isCompleted"]
 233                 )
 234                 # filteredTasks = (taskDetails for taskDetails in filteredTasks if item_in_agenda(taskDetails))
 235                 sortedTasks = item_sort_by_priority_then_date(filteredTasks)
 236                 # sortedTasks = item_sort_by_date_then_priority(filteredTasks)
 237                 # sortedTasks = item_sort_by_fuzzydate_then_priority(filteredTasks)
 238                 for taskDetails in sortedTasks:
 239                         id = taskDetails["id"]
 240                         isCompleted = taskDetails["isCompleted"]
 241                         name = abbreviate(taskDetails["name"], 100)
 242                         priority = str(taskDetails["priority"].get_nothrow(""))
 243                         if taskDetails["dueDate"].is_good():
 244                                 dueDate = taskDetails["dueDate"].get()
 245                                 dueDescription = dueDate.strftime("%Y-%m-%d %H:%M:%S")
 246                                 fuzzyDue = toolbox.to_fuzzy_date(dueDate)
 247                         else:
 248                                 dueDescription = ""
 249                                 fuzzyDue = ""
 250
 251                         linkDisplay = taskDetails["url"]
 252                         linkDisplay = abbreviate_url(linkDisplay, 20, 10)
 253
 254                         notes = taskDetails["notes"]
 255                         notesDisplay = "%d Notes" % len(notes) if notes else ""
 256
 257                         row = (id, isCompleted, name, priority, dueDescription, fuzzyDue, linkDisplay, notesDisplay)
 258                         self._itemList.append(row)
 259                 self._todoItemTree.set_model(self._itemList)
 260
 261         def _on_item_select(self, treeView, path, viewColumn):
 262                 # @todo See if there is a way to use the new gtk_toolbox.ContextHandler
 263                 taskId = self._itemList[path[0]][self.ID_IDX]
 264
 265                 if viewColumn is self._priorityColumn:
 266                         pass
 267                 elif viewColumn is self._nameColumn:
 268                         self._editDialog.enable(self._manager)
 269                         try:
 270                                 self._editDialog.request_task(self._manager, taskId)
 271                         finally:
 272                                 self._editDialog.disable()
 273                         self.reset_task_list(self._projId)
 274                 elif viewColumn is self._dueColumn:
 275                         self._editDialog.enable(self._manager)
 276                         try:
 277                                 self._editDialog.request_task(self._manager, taskId)
 278                         finally:
 279                                 self._editDialog.disable()
 280                         self.reset_task_list(self._projId)
 281                 elif viewColumn is self._linkColumn:
 282                         webbrowser.open(self._manager.get_task_details(taskId)["url"])
 283                 elif viewColumn is self._notesColumn:
 284                         pass
 285
 286         def _on_completion_change(self, cell, path):
 287                 taskId = self._itemList[path[0]][self.ID_IDX]
 288                 self._manager.complete_task(taskId)
 289                 self.reset_task_list(self._projId)
 290
 291
 292 class ItemAgendaView(object):
 293         pass
 294
 295
 296 class GtkRtMilk(object):
 297
 298         def __init__(self, widgetTree):
 299                 """
 300                 @note Thread agnostic
 301                 """
 302                 self._manager = None
 303                 self._credentials = "", "", ""
 304
 305                 self._clipboard = gtk.clipboard_get()
 306                 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
 307
 308                 self._projectsList = gtk.ListStore(gobject.TYPE_STRING)
 309                 self._projectsCombo = widgetTree.get_widget("projectsCombo")
 310                 self._onListActivateId = 0
 311
 312                 self._taskNameEntry = widgetTree.get_widget("add-taskNameEntry")
 313                 self._addTaskButton = widgetTree.get_widget("add-addTaskButton")
 314                 self._pasteTaskNameButton = widgetTree.get_widget("add-pasteTaskNameButton")
 315                 self._clearTaskNameButton = widgetTree.get_widget("add-clearTaskNameButton")
 316                 self._onAddId = None
 317                 self._onAddClickedId = None
 318                 self._onAddReleasedId = None
 319                 self._addToEditTimerId = None
 320                 self._onClearId = None
 321                 self._onPasteId = None
 322
 323                 self._itemView = ItemListView(widgetTree)
 324                 self._credentialsDialog = gtk_toolbox.LoginWindow(widgetTree)
 325
 326         @staticmethod
 327         def name():
 328                 return "Remember The Milk"
 329
 330         def load_settings(self, config):
 331                 """
 332                 @note Thread Agnostic
 333                 """
 334                 blobs = (
 335                         config.get(self.name(), "bin_blob_%i" % i)
 336                         for i in xrange(len(self._credentials))
 337                 )
 338                 creds = (
 339                         base64.b64decode(blob)
 340                         for blob in blobs
 341                 )
 342                 self._credentials = tuple(creds)
 343
 344         def save_settings(self, config):
 345                 """
 346                 @note Thread Agnostic
 347                 """
 348                 config.add_section(self.name())
 349                 for i, value in enumerate(self._credentials):
 350                         blob = base64.b64encode(value)
 351                         config.set(self.name(), "bin_blob_%i" % i, blob)
 352
 353         def login(self):
 354                 """
 355                 @note UI Thread
 356                 """
 357                 if self._manager is not None:
 358                         return
 359
 360                 credentials = self._credentials
 361                 while True:
 362                         try:
 363                                 self._manager = rtm_backend.RtMilkManager(*credentials)
 364                                 self._credentials = credentials
 365                                 return # Login succeeded
 366                         except rtm_api.AuthStateMachine.NoData:
 367                                 # Login failed, grab new credentials
 368                                 credentials = get_credentials(self._credentialsDialog)
 369
 370         def logout(self):
 371                 """
 372                 @note Thread Agnostic
 373                 """
 374                 self._credentials = "", "", ""
 375                 self._manager = None
 376
 377         def enable(self):
 378                 """
 379                 @note UI Thread
 380                 """
 381                 self._projectsList.clear()
 382                 self._populate_projects()
 383
 384                 currentProject = self._get_project()
 385                 projId = self._manager.lookup_project(currentProject)["id"]
 386                 self._itemView.enable(self._manager, projId)
 387
 388                 self._onListActivateId = self._projectsCombo.connect("changed", self._on_list_activate)
 389                 self._onAddId = self._addTaskButton.connect("clicked", self._on_add)
 390                 self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed)
 391                 self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released)
 392                 self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste)
 393                 self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear)
 394
 395         def disable(self):
 396                 """
 397                 @note UI Thread
 398                 """
 399                 self._projectsCombo.disconnect(self._onListActivateId)
 400                 self._addTaskButton.disconnect(self._onAddId)
 401                 self._addTaskButton.disconnect(self._onAddClickedId)
 402                 self._addTaskButton.disconnect(self._onAddReleasedId)
 403                 self._pasteTaskNameButton.disconnect(self._onPasteId)
 404                 self._clearTaskNameButton.disconnect(self._onClearId)
 405
 406                 self._itemView.disable()
 407
 408                 self._projectsList.clear()
 409                 self._projectsCombo.set_model(None)
 410                 self._projectsCombo.disconnect("changed", self._on_list_activate)
 411
 412                 self._manager = None
 413
 414         def _populate_projects(self):
 415                 for project in self._manager.get_projects():
 416                         projectName = project["name"]
 417                         isVisible = project["isVisible"]
 418                         row = (projectName, )
 419                         if isVisible:
 420                                 self._projectsList.append(row)
 421                 self._projectsCombo.set_model(self._projectsList)
 422                 cell = gtk.CellRendererText()
 423                 self._projectsCombo.pack_start(cell, True)
 424                 self._projectsCombo.add_attribute(cell, 'text', 0)
 425                 self._projectsCombo.set_active(0)
 426
 427         def _reset_task_list(self):
 428                 currentProject = self._get_project()
 429                 projId = self._manager.lookup_project(currentProject)["id"]
 430                 isMeta = self._manager.get_project(projId)["isMeta"]
 431                 # @todo RTM handles this by defaulting to a specific list
 432                 self._addTaskButton.set_sensitive(not isMeta)
 433
 434                 self._itemView.reset_task_list(projId)
 435
 436         def _get_project(self):
 437                 currentProjectName = self._projectsCombo.get_active_text()
 438                 return currentProjectName
 439
 440         def _on_list_activate(self, *args):
 441                 self._reset_task_list()
 442
 443         def _on_add(self, *args):
 444                 name = self._taskNameEntry.get_text()
 445
 446                 currentProject = self._get_project()
 447                 projId = self._manager.lookup_project(currentProject)["id"]
 448                 taskId = self._manager.add_task(projId, name)
 449
 450                 self._taskNameEntry.set_text("")
 451                 self._reset_task_list()
 452
 453         def _on_add_edit(self, *args):
 454                 name = self._taskNameEntry.get_text()
 455
 456                 currentProject = self._get_project()
 457                 projId = self._manager.lookup_project(currentProject)["id"]
 458                 taskId = self._manager.add_task(projId, name)
 459
 460                 try:
 461                         self._editDialog.enable(self._manager)
 462                         try:
 463                                 self._editDialog.request_task(self._manager, taskId)
 464                         finally:
 465                                 self._editDialog.disable()
 466                 finally:
 467                         self._taskNameEntry.set_text("")
 468                         self._reset_task_list()
 469
 470         def _on_add_pressed(self, widget):
 471                 self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit)
 472
 473         def _on_add_released(self, widget):
 474                 if self._addToEditTimerId is not None:
 475                         gobject.source_remove(self._addToEditTimerId)
 476                 self._addToEditTimerId = None
 477
 478         def _on_paste(self, *args):
 479                 entry = self._taskNameEntry.get_text()
 480                 entry += self._clipboard.wait_for_text()
 481                 self._taskNameEntry.set_text(entry)
 482
 483         def _on_clear(self, *args):
 484                 self._taskNameEntry.set_text("")