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, errorDisplay):
 133                 self._errorDisplay = errorDisplay
 134                 self._manager = None
 135                 self._projId = None
 136                 self._showCompleted = False
 137                 self._showIncomplete = True
 138
 139                 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
 140
 141                 self._itemList = gtk.ListStore(
 142                         gobject.TYPE_STRING, # id
 143                         gobject.TYPE_BOOLEAN, # is complete
 144                         gobject.TYPE_STRING, # name
 145                         gobject.TYPE_STRING, # priority
 146                         gobject.TYPE_STRING, # due
 147                         gobject.TYPE_STRING, # fuzzy due
 148                         gobject.TYPE_STRING, # Link
 149                         gobject.TYPE_STRING, # Notes
 150                 )
 151                 self._completionColumn = gtk.TreeViewColumn('') # Complete?
 152                 self._completionCell = gtk.CellRendererToggle()
 153                 self._completionCell.set_property("activatable", True)
 154                 self._completionCell.connect("toggled", self._on_completion_change)
 155                 self._completionColumn.pack_start(self._completionCell, False)
 156                 self._completionColumn.set_attributes(self._completionCell, active=self.COMPLETION_IDX)
 157                 self._priorityColumn = gtk.TreeViewColumn('') # Priority
 158                 self._priorityCell = gtk.CellRendererText()
 159                 self._priorityColumn.pack_start(self._priorityCell, False)
 160                 self._priorityColumn.set_attributes(self._priorityCell, text=self.PRIORITY_IDX)
 161                 self._nameColumn = gtk.TreeViewColumn('Name')
 162                 self._nameCell = gtk.CellRendererText()
 163                 self._nameColumn.pack_start(self._nameCell, True)
 164                 self._nameColumn.set_attributes(self._nameCell, text=self.NAME_IDX)
 165                 self._dueColumn = gtk.TreeViewColumn('Due')
 166                 self._dueCell = gtk.CellRendererText()
 167                 self._dueColumn.pack_start(self._nameCell, False)
 168                 self._dueColumn.set_attributes(self._nameCell, text=self.FUZZY_IDX)
 169                 self._linkColumn = gtk.TreeViewColumn('') # Link
 170                 self._linkCell = gtk.CellRendererText()
 171                 self._linkColumn.pack_start(self._nameCell, False)
 172                 self._linkColumn.set_attributes(self._nameCell, text=self.LINK_IDX)
 173                 self._notesColumn = gtk.TreeViewColumn('') # Notes
 174                 self._notesCell = gtk.CellRendererText()
 175                 self._notesColumn.pack_start(self._nameCell, False)
 176                 self._notesColumn.set_attributes(self._nameCell, text=self.NOTES_IDX)
 177
 178                 self._todoBox = widgetTree.get_widget("todoBox")
 179                 self._todoItemScroll = gtk.ScrolledWindow()
 180                 self._todoItemScroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
 181                 self._todoItemTree = gtk.TreeView()
 182                 self._todoItemScroll.add(self._todoItemTree)
 183                 self._onItemSelectId = 0
 184
 185         def enable(self, manager, projId):
 186                 self._manager = manager
 187                 self._projId = projId
 188
 189                 self._todoBox.pack_start(self._todoItemScroll)
 190                 self._todoItemScroll.show_all()
 191
 192                 self._itemList.clear()
 193                 self._todoItemTree.append_column(self._completionColumn)
 194                 self._todoItemTree.append_column(self._priorityColumn)
 195                 self._todoItemTree.append_column(self._nameColumn)
 196                 self._todoItemTree.append_column(self._dueColumn)
 197                 self._todoItemTree.append_column(self._linkColumn)
 198                 self._todoItemTree.append_column(self._notesColumn)
 199                 try:
 200                         self.reset_task_list(self._projId)
 201                 except StandardError, e:
 202                         self._errorDisplay.push_exception()
 203
 204                 self._todoItemTree.set_headers_visible(False)
 205                 self._nameColumn.set_expand(True)
 206
 207                 self._onItemSelectId = self._todoItemTree.connect("row-activated", self._on_item_select)
 208
 209         def disable(self):
 210                 self._manager = None
 211                 self._projId = None
 212
 213                 self._todoBox.remove(self._todoItemScroll)
 214                 self._todoItemScroll.hide_all()
 215                 self._todoItemTree.disconnect(self._onItemSelectId)
 216
 217                 self._todoItemTree.remove_column(self._completionColumn)
 218                 self._todoItemTree.remove_column(self._priorityColumn)
 219                 self._todoItemTree.remove_column(self._nameColumn)
 220                 self._todoItemTree.remove_column(self._dueColumn)
 221                 self._todoItemTree.remove_column(self._linkColumn)
 222                 self._todoItemTree.remove_column(self._notesColumn)
 223                 self._itemList.clear()
 224                 self._itemList.set_model(None)
 225
 226         def reset_task_list(self, projId):
 227                 self._projId = projId
 228                 self._itemList.clear()
 229                 self._populate_items()
 230
 231         def _populate_items(self):
 232                 projId = self._projId
 233                 rawTasks = self._manager.get_tasks_with_details(projId)
 234                 filteredTasks = (
 235                         taskDetails
 236                         for taskDetails in rawTasks
 237                                 if self._showCompleted and taskDetails["isCompleted"] or self._showIncomplete and not taskDetails["isCompleted"]
 238                 )
 239                 # filteredTasks = (taskDetails for taskDetails in filteredTasks if item_in_agenda(taskDetails))
 240                 sortedTasks = item_sort_by_priority_then_date(filteredTasks)
 241                 # sortedTasks = item_sort_by_date_then_priority(filteredTasks)
 242                 # sortedTasks = item_sort_by_fuzzydate_then_priority(filteredTasks)
 243                 for taskDetails in sortedTasks:
 244                         id = taskDetails["id"]
 245                         isCompleted = taskDetails["isCompleted"]
 246                         name = abbreviate(taskDetails["name"], 100)
 247                         priority = str(taskDetails["priority"].get_nothrow(""))
 248                         if taskDetails["dueDate"].is_good():
 249                                 dueDate = taskDetails["dueDate"].get()
 250                                 dueDescription = dueDate.strftime("%Y-%m-%d %H:%M:%S")
 251                                 fuzzyDue = toolbox.to_fuzzy_date(dueDate)
 252                         else:
 253                                 dueDescription = ""
 254                                 fuzzyDue = ""
 255
 256                         linkDisplay = taskDetails["url"]
 257                         linkDisplay = abbreviate_url(linkDisplay, 20, 10)
 258
 259                         notes = taskDetails["notes"]
 260                         notesDisplay = "%d Notes" % len(notes) if notes else ""
 261
 262                         row = (id, isCompleted, name, priority, dueDescription, fuzzyDue, linkDisplay, notesDisplay)
 263                         self._itemList.append(row)
 264                 self._todoItemTree.set_model(self._itemList)
 265
 266         def _on_item_select(self, treeView, path, viewColumn):
 267                 try:
 268                         # @todo See if there is a way to use the new gtk_toolbox.ContextHandler
 269                         taskId = self._itemList[path[0]][self.ID_IDX]
 270
 271                         if viewColumn is self._priorityColumn:
 272                                 pass
 273                         elif viewColumn is self._nameColumn:
 274                                 self._editDialog.enable(self._manager)
 275                                 try:
 276                                         self._editDialog.request_task(self._manager, taskId)
 277                                 finally:
 278                                         self._editDialog.disable()
 279                                 self.reset_task_list(self._projId)
 280                         elif viewColumn is self._dueColumn:
 281                                 self._editDialog.enable(self._manager)
 282                                 try:
 283                                         self._editDialog.request_task(self._manager, taskId)
 284                                 finally:
 285                                         self._editDialog.disable()
 286                                 self.reset_task_list(self._projId)
 287                         elif viewColumn is self._linkColumn:
 288                                 webbrowser.open(self._manager.get_task_details(taskId)["url"])
 289                         elif viewColumn is self._notesColumn:
 290                                 pass
 291                 except StandardError, e:
 292                         self._errorDisplay.push_exception()
 293
 294         def _on_completion_change(self, cell, path):
 295                 try:
 296                         taskId = self._itemList[path[0]][self.ID_IDX]
 297                         self._manager.complete_task(taskId)
 298                         self.reset_task_list(self._projId)
 299                 except StandardError, e:
 300                         self._errorDisplay.push_exception()
 301
 302
 303 class QuickAddView(object):
 304
 305         def __init__(self, widgetTree, errorDisplay, addSink):
 306                 self._errorDisplay = errorDisplay
 307                 self._manager = None
 308                 self._projId = None
 309                 self._addSink = addSink
 310
 311                 self._clipboard = gtk.clipboard_get()
 312                 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
 313
 314                 self._taskNameEntry = widgetTree.get_widget("add-taskNameEntry")
 315                 self._addTaskButton = widgetTree.get_widget("add-addTaskButton")
 316                 self._pasteTaskNameButton = widgetTree.get_widget("add-pasteTaskNameButton")
 317                 self._clearTaskNameButton = widgetTree.get_widget("add-clearTaskNameButton")
 318                 self._onAddId = None
 319                 self._onAddClickedId = None
 320                 self._onAddReleasedId = None
 321                 self._addToEditTimerId = None
 322                 self._onClearId = None
 323                 self._onPasteId = None
 324
 325         def enable(self, manager, projId):
 326                 self._manager = manager
 327                 self._projId = projId
 328
 329                 self._onAddId = self._addTaskButton.connect("clicked", self._on_add)
 330                 self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed)
 331                 self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released)
 332                 self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste)
 333                 self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear)
 334
 335         def disable(self):
 336                 self._manager = None
 337                 self._projId = None
 338
 339                 self._addTaskButton.disconnect(self._onAddId)
 340                 self._addTaskButton.disconnect(self._onAddClickedId)
 341                 self._addTaskButton.disconnect(self._onAddReleasedId)
 342                 self._pasteTaskNameButton.disconnect(self._onPasteId)
 343                 self._clearTaskNameButton.disconnect(self._onClearId)
 344
 345         def reset_task_list(self, projId):
 346                 self._projId = projId
 347                 isMeta = self._manager.get_project(self._projId)["isMeta"]
 348                 # @todo RTM handles this by defaulting to a specific list
 349                 self._addTaskButton.set_sensitive(not isMeta)
 350
 351         def _on_add(self, *args):
 352                 try:
 353                         name = self._taskNameEntry.get_text()
 354
 355                         projId = self._projId
 356                         taskId = self._manager.add_task(projId, name)
 357
 358                         self._taskNameEntry.set_text("")
 359                         self._addSink.send((projId, taskId))
 360                 except StandardError, e:
 361                         self._errorDisplay.push_exception()
 362
 363         def _on_add_edit(self, *args):
 364                 try:
 365                         name = self._taskNameEntry.get_text()
 366
 367                         projId = self._projId
 368                         taskId = self._manager.add_task(projId, name)
 369
 370                         try:
 371                                 self._editDialog.enable(self._manager)
 372                                 try:
 373                                         self._editDialog.request_task(self._manager, taskId)
 374                                 finally:
 375                                         self._editDialog.disable()
 376                         finally:
 377                                 self._taskNameEntry.set_text("")
 378                                 self._addSink.send((projId, taskId))
 379                 except StandardError, e:
 380                         self._errorDisplay.push_exception()
 381
 382         def _on_add_pressed(self, widget):
 383                 try:
 384                         self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit)
 385                 except StandardError, e:
 386                         self._errorDisplay.push_exception()
 387
 388         def _on_add_released(self, widget):
 389                 try:
 390                         if self._addToEditTimerId is not None:
 391                                 gobject.source_remove(self._addToEditTimerId)
 392                         self._addToEditTimerId = None
 393                 except StandardError, e:
 394                         self._errorDisplay.push_exception()
 395
 396         def _on_paste(self, *args):
 397                 try:
 398                         entry = self._taskNameEntry.get_text()
 399                         entry += self._clipboard.wait_for_text()
 400                         self._taskNameEntry.set_text(entry)
 401                 except StandardError, e:
 402                         self._errorDisplay.push_exception()
 403
 404         def _on_clear(self, *args):
 405                 try:
 406                         self._taskNameEntry.set_text("")
 407                 except StandardError, e:
 408                         self._errorDisplay.push_exception()
 409
 410
 411 class GtkRtMilk(object):
 412
 413         def __init__(self, widgetTree, errorDisplay):
 414                 """
 415                 @note Thread agnostic
 416                 """
 417                 self._errorDisplay = errorDisplay
 418                 self._manager = None
 419                 self._credentials = "", "", ""
 420
 421                 self._projectsList = gtk.ListStore(gobject.TYPE_STRING)
 422                 self._projectsCombo = widgetTree.get_widget("projectsCombo")
 423                 self._onListActivateId = 0
 424
 425                 self._itemView = ItemListView(widgetTree, self._errorDisplay)
 426                 addSink = coroutines.func_sink(lambda eventData: self._itemView.reset_task_list(eventData[0]))
 427                 self._addView = QuickAddView(widgetTree, self._errorDisplay, addSink)
 428                 self._credentialsDialog = gtk_toolbox.LoginWindow(widgetTree)
 429
 430         @staticmethod
 431         def name():
 432                 return "Remember The Milk"
 433
 434         def load_settings(self, config):
 435                 """
 436                 @note Thread Agnostic
 437                 """
 438                 blobs = (
 439                         config.get(self.name(), "bin_blob_%i" % i)
 440                         for i in xrange(len(self._credentials))
 441                 )
 442                 creds = (
 443                         base64.b64decode(blob)
 444                         for blob in blobs
 445                 )
 446                 self._credentials = tuple(creds)
 447
 448         def save_settings(self, config):
 449                 """
 450                 @note Thread Agnostic
 451                 """
 452                 config.add_section(self.name())
 453                 for i, value in enumerate(self._credentials):
 454                         blob = base64.b64encode(value)
 455                         config.set(self.name(), "bin_blob_%i" % i, blob)
 456
 457         def login(self):
 458                 """
 459                 @note UI Thread
 460                 """
 461                 if self._manager is not None:
 462                         return
 463
 464                 credentials = self._credentials
 465                 while True:
 466                         try:
 467                                 self._manager = rtm_backend.RtMilkManager(*credentials)
 468                                 self._credentials = credentials
 469                                 return # Login succeeded
 470                         except rtm_api.AuthStateMachine.NoData:
 471                                 # Login failed, grab new credentials
 472                                 credentials = get_credentials(self._credentialsDialog)
 473
 474         def logout(self):
 475                 """
 476                 @note Thread Agnostic
 477                 """
 478                 self._credentials = "", "", ""
 479                 self._manager = None
 480
 481         def enable(self):
 482                 """
 483                 @note UI Thread
 484                 """
 485                 self._projectsList.clear()
 486                 self._populate_projects()
 487
 488                 currentProject = self._get_project()
 489                 projId = self._manager.lookup_project(currentProject)["id"]
 490                 self._addView.enable(self._manager, projId)
 491                 self._itemView.enable(self._manager, projId)
 492
 493                 self._onListActivateId = self._projectsCombo.connect("changed", self._on_list_activate)
 494
 495         def disable(self):
 496                 """
 497                 @note UI Thread
 498                 """
 499                 self._projectsCombo.disconnect(self._onListActivateId)
 500
 501                 self._addView.disable()
 502                 self._itemView.disable()
 503
 504                 self._projectsList.clear()
 505                 self._projectsCombo.set_model(None)
 506                 self._projectsCombo.disconnect("changed", self._on_list_activate)
 507
 508                 self._manager = None
 509
 510         def _populate_projects(self):
 511                 for project in self._manager.get_projects():
 512                         projectName = project["name"]
 513                         isVisible = project["isVisible"]
 514                         row = (projectName, )
 515                         if isVisible:
 516                                 self._projectsList.append(row)
 517                 self._projectsCombo.set_model(self._projectsList)
 518                 cell = gtk.CellRendererText()
 519                 self._projectsCombo.pack_start(cell, True)
 520                 self._projectsCombo.add_attribute(cell, 'text', 0)
 521                 self._projectsCombo.set_active(0)
 522
 523         def _reset_task_list(self):
 524                 projectName = self._get_project()
 525                 projId = self._manager.lookup_project(projectName)["id"]
 526                 self._addView.reset_task_list(projId)
 527                 self._itemView.reset_task_list(projId)
 528
 529         def _get_project(self):
 530                 currentProjectName = self._projectsCombo.get_active_text()
 531                 return currentProjectName
 532
 533         def _on_list_activate(self, *args):
 534                 try:
 535                         self._reset_task_list()
 536                 except StandardError, e:
 537                         self._errorDisplay.push_exception()