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_agenda_sort_by_date_then_priority(items):
 105         sortedTasks = list(item for item in items if item_in_agenda(item))
 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                 sortedTasks = item_sort_by_priority_then_date(filteredTasks)
 235                 # sortedTasks = item_sort_by_date_then_priority(filteredTasks)
 236                 # sortedTasks = item_agenda_sort_by_date_then_priority(filteredTasks)
 237                 for taskDetails in sortedTasks:
 238                         id = taskDetails["id"]
 239                         isCompleted = taskDetails["isCompleted"]
 240                         name = abbreviate(taskDetails["name"], 100)
 241                         priority = str(taskDetails["priority"].get_nothrow(""))
 242                         if taskDetails["dueDate"].is_good():
 243                                 dueDate = taskDetails["dueDate"].get()
 244                                 dueDescription = dueDate.strftime("%Y-%m-%d %H:%M:%S")
 245                                 fuzzyDue = toolbox.to_fuzzy_date(dueDate)
 246                         else:
 247                                 dueDescription = ""
 248                                 fuzzyDue = ""
 249
 250                         linkDisplay = taskDetails["url"]
 251                         linkDisplay = abbreviate_url(linkDisplay, 20, 10)
 252
 253                         notes = taskDetails["notes"]
 254                         notesDisplay = "%d Notes" % len(notes) if notes else ""
 255
 256                         row = (id, isCompleted, name, priority, dueDescription, fuzzyDue, linkDisplay, notesDisplay)
 257                         self._itemList.append(row)
 258                 self._todoItemTree.set_model(self._itemList)
 259
 260         def _on_item_select(self, treeView, path, viewColumn):
 261                 # @todo See if there is a way to use the new gtk_toolbox.ContextHandler
 262                 taskId = self._itemList[path[0]][self.ID_IDX]
 263
 264                 if viewColumn is self._priorityColumn:
 265                         pass
 266                 elif viewColumn is self._nameColumn:
 267                         self._editDialog.enable(self._manager)
 268                         try:
 269                                 self._editDialog.request_task(self._manager, taskId)
 270                         finally:
 271                                 self._editDialog.disable()
 272                         self.reset_task_list(self._projId)
 273                 elif viewColumn is self._dueColumn:
 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._linkColumn:
 281                         webbrowser.open(self._manager.get_task_details(taskId)["url"])
 282                 elif viewColumn is self._notesColumn:
 283                         pass
 284
 285         def _on_completion_change(self, cell, path):
 286                 taskId = self._itemList[path[0]][self.ID_IDX]
 287                 self._manager.complete_task(taskId)
 288                 self.reset_task_list(self._projId)
 289
 290
 291 class ItemAgendaView(object):
 292         pass
 293
 294
 295 class GtkRtMilk(object):
 296
 297         def __init__(self, widgetTree):
 298                 """
 299                 @note Thread agnostic
 300                 """
 301                 self._manager = None
 302                 self._credentials = "", "", ""
 303
 304                 self._clipboard = gtk.clipboard_get()
 305                 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
 306
 307                 self._projectsList = gtk.ListStore(gobject.TYPE_STRING)
 308                 self._projectsCombo = widgetTree.get_widget("projectsCombo")
 309                 self._onListActivateId = 0
 310
 311                 self._taskNameEntry = widgetTree.get_widget("add-taskNameEntry")
 312                 self._addTaskButton = widgetTree.get_widget("add-addTaskButton")
 313                 self._pasteTaskNameButton = widgetTree.get_widget("add-pasteTaskNameButton")
 314                 self._clearTaskNameButton = widgetTree.get_widget("add-clearTaskNameButton")
 315                 self._onAddId = None
 316                 self._onAddClickedId = None
 317                 self._onAddReleasedId = None
 318                 self._addToEditTimerId = None
 319                 self._onClearId = None
 320                 self._onPasteId = None
 321
 322                 self._itemView = ItemListView(widgetTree)
 323                 self._credentialsDialog = gtk_toolbox.LoginWindow(widgetTree)
 324
 325         @staticmethod
 326         def name():
 327                 return "Remember The Milk"
 328
 329         def load_settings(self, config):
 330                 """
 331                 @note Thread Agnostic
 332                 """
 333                 blobs = (
 334                         config.get(self.name(), "bin_blob_%i" % i)
 335                         for i in xrange(len(self._credentials))
 336                 )
 337                 creds = (
 338                         base64.b64decode(blob)
 339                         for blob in blobs
 340                 )
 341                 self._credentials = tuple(creds)
 342
 343         def save_settings(self, config):
 344                 """
 345                 @note Thread Agnostic
 346                 """
 347                 config.add_section(self.name())
 348                 for i, value in enumerate(self._credentials):
 349                         blob = base64.b64encode(value)
 350                         config.set(self.name(), "bin_blob_%i" % i, blob)
 351
 352         def login(self):
 353                 """
 354                 @note UI Thread
 355                 """
 356                 if self._manager is not None:
 357                         return
 358
 359                 credentials = self._credentials
 360                 while True:
 361                         try:
 362                                 self._manager = rtm_backend.RtMilkManager(*credentials)
 363                                 self._credentials = credentials
 364                                 return # Login succeeded
 365                         except rtm_api.AuthStateMachine.NoData:
 366                                 # Login failed, grab new credentials
 367                                 credentials = get_credentials(self._credentialsDialog)
 368
 369         def logout(self):
 370                 """
 371                 @note Thread Agnostic
 372                 """
 373                 self._credentials = "", "", ""
 374                 self._manager = None
 375
 376         def enable(self):
 377                 """
 378                 @note UI Thread
 379                 """
 380                 self._projectsList.clear()
 381                 self._populate_projects()
 382
 383                 currentProject = self._get_project()
 384                 projId = self._manager.lookup_project(currentProject)["id"]
 385                 self._itemView.enable(self._manager, projId)
 386
 387                 self._onListActivateId = self._projectsCombo.connect("changed", self._on_list_activate)
 388                 self._onAddId = self._addTaskButton.connect("clicked", self._on_add)
 389                 self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed)
 390                 self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released)
 391                 self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste)
 392                 self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear)
 393
 394         def disable(self):
 395                 """
 396                 @note UI Thread
 397                 """
 398                 self._projectsCombo.disconnect(self._onListActivateId)
 399                 self._addTaskButton.disconnect(self._onAddId)
 400                 self._addTaskButton.disconnect(self._onAddClickedId)
 401                 self._addTaskButton.disconnect(self._onAddReleasedId)
 402                 self._pasteTaskNameButton.disconnect(self._onPasteId)
 403                 self._clearTaskNameButton.disconnect(self._onClearId)
 404
 405                 self._itemView.disable()
 406
 407                 self._projectsList.clear()
 408                 self._projectsCombo.set_model(None)
 409                 self._projectsCombo.disconnect("changed", self._on_list_activate)
 410
 411                 self._manager = None
 412
 413         def _populate_projects(self):
 414                 for project in self._manager.get_projects():
 415                         projectName = project["name"]
 416                         isVisible = project["isVisible"]
 417                         row = (projectName, )
 418                         if isVisible:
 419                                 self._projectsList.append(row)
 420                 self._projectsCombo.set_model(self._projectsList)
 421                 cell = gtk.CellRendererText()
 422                 self._projectsCombo.pack_start(cell, True)
 423                 self._projectsCombo.add_attribute(cell, 'text', 0)
 424                 self._projectsCombo.set_active(0)
 425
 426         def _reset_task_list(self):
 427                 currentProject = self._get_project()
 428                 projId = self._manager.lookup_project(currentProject)["id"]
 429                 isMeta = self._manager.get_project(projId)["isMeta"]
 430                 # @todo RTM handles this by defaulting to a specific list
 431                 self._addTaskButton.set_sensitive(not isMeta)
 432
 433                 self._itemView.reset_task_list(projId)
 434
 435         def _get_project(self):
 436                 currentProjectName = self._projectsCombo.get_active_text()
 437                 return currentProjectName
 438
 439         def _on_list_activate(self, *args):
 440                 self._reset_task_list()
 441
 442         def _on_add(self, *args):
 443                 name = self._taskNameEntry.get_text()
 444
 445                 currentProject = self._get_project()
 446                 projId = self._manager.lookup_project(currentProject)["id"]
 447                 taskId = self._manager.add_task(projId, name)
 448
 449                 self._taskNameEntry.set_text("")
 450                 self._reset_task_list()
 451
 452         def _on_add_edit(self, *args):
 453                 name = self._taskNameEntry.get_text()
 454
 455                 currentProject = self._get_project()
 456                 projId = self._manager.lookup_project(currentProject)["id"]
 457                 taskId = self._manager.add_task(projId, name)
 458
 459                 try:
 460                         self._editDialog.enable(self._manager)
 461                         try:
 462                                 self._editDialog.request_task(self._manager, taskId)
 463                         finally:
 464                                 self._editDialog.disable()
 465                 finally:
 466                         self._taskNameEntry.set_text("")
 467                         self._reset_task_list()
 468
 469         def _on_add_pressed(self, widget):
 470                 self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit)
 471
 472         def _on_add_released(self, widget):
 473                 if self._addToEditTimerId is not None:
 474                         gobject.source_remove(self._addToEditTimerId)
 475                 self._addToEditTimerId = None
 476
 477         def _on_paste(self, *args):
 478                 entry = self._taskNameEntry.get_text()
 479                 entry += self._clipboard.wait_for_text()
 480                 self._taskNameEntry.set_text(entry)
 481
 482         def _on_clear(self, *args):
 483                 self._taskNameEntry.set_text("")