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