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

   1 """
   2 @todo Write and eager cache which will then, combined with file_backend, will be the basis of sync
   3 """
   4
   5
   6 class LazyCacheBackend(object):
   7
   8         def __init__(self, backend):
   9                 self._backend = backend
  10                 self._projects = {}
  11                 self._items = {}
  12                 self._locations = {}
  13                 self._taskIdToProjId = {}
  14                 self._noteIdToTaskId = {}
  15
  16         def save(self):
  17                 self._backend.save()
  18
  19         def load(self):
  20                 self._backend.load()
  21
  22         def add_project(self, name):
  23                 projId = self._backend.add_project(name)
  24                 self._invalidate_projects()
  25                 return projId
  26
  27         def set_project_name(self, projId, name):
  28                 self._backend.set_project_name(projId, name)
  29                 self._invalidate_projects()
  30
  31         def set_project_visibility(self, projId, visibility):
  32                 self._backend.set_project_visibility(projId, visibility)
  33                 self._invalidate_projects()
  34
  35         def get_projects(self):
  36                 self._populate_projects()
  37                 return self._projects.itervalues()
  38
  39         def get_project(self, projId):
  40                 self._populate_projects()
  41                 return self._projects[projId]
  42
  43         def lookup_project(self, projName):
  44                 """
  45                 From a project's name, returns the project's details
  46                 """
  47                 self._populate_projects()
  48                 todoList = [
  49                         projectDetails
  50                         for projectDetails in self._projects.itervalues()
  51                                 if projectDetails["name"] == projName
  52                 ]
  53                 assert len(todoList) == 1, "Wrong number of lists found for %s, in %r" % (projName, todoList)
  54                 return todoList[0]
  55
  56         def get_locations(self):
  57                 self._populate_locations()
  58                 return self._locations.itervalues()
  59
  60         def get_tasks_with_details(self, projId):
  61                 self._populate_tasks(projId)
  62                 return self._items[projId].itervalues()
  63
  64         def get_task_details(self, taskId):
  65                 projId = self._taskIdToProjId[taskId]
  66                 self._populate_tasks(projId)
  67                 return self._items[projId][taskId]
  68
  69         def add_task(self, projId, taskName):
  70                 taskId = self._backend.add_task(projId, taskName)
  71                 self._invalidate_projects_tasks(projId)
  72                 self._invalidate_metaprojects_tasks()
  73                 return taskId
  74
  75         def set_project(self, taskId, newProjId):
  76                 self._backend.set_project(taskId, newProjId)
  77                 projId = self._taskIdToProjId[taskId]
  78                 self._invalidate_projects_tasks(projId)
  79                 self._invalidate_projects_tasks(newProjId)
  80                 self._invalidate_metaprojects_tasks()
  81
  82         def set_name(self, taskId, name):
  83                 self._backend.set_name(taskId, name)
  84                 self._invalidate_task(taskId)
  85
  86         def set_duedate(self, taskId, dueDate):
  87                 self._backend.set_duedate(taskId, dueDate)
  88                 self._invalidate_task(taskId)
  89
  90         def set_priority(self, taskId, priority):
  91                 self._backend.set_priority(taskId, priority)
  92                 self._invalidate_task(taskId)
  93
  94         def complete_task(self, taskId):
  95                 self._backend.complete_task(taskId)
  96                 self._invalidate_task(taskId)
  97
  98         def add_note(self, taskId, noteTitle, noteBody):
  99                 noteId = self._backend.add_note(taskId, noteTitle, noteBody)
 100                 self._invalidate_task(taskId)
 101                 return noteId
 102
 103         def update_note(self, noteId, noteTitle, noteBody):
 104                 self._backend.update_note(noteId, noteTitle, noteBody)
 105                 taskId = self._noteIdToTaskId[noteId]
 106                 self._invalidate_task(taskId)
 107
 108         def delete_note(self, noteId):
 109                 self._backend.delete_note(noteId)
 110                 taskId = self._noteIdToTaskId[noteId]
 111                 del self._noteIdToTaskId[noteId]
 112                 self._invalidate_task(taskId)
 113
 114         def _populate_projects(self):
 115                 if self._projects:
 116                         print "SAVED BY THE CACHE"
 117                         return
 118                 self._projects = dict((
 119                         (proj["id"], proj)
 120                         for proj in self._backend.get_projects()
 121                 ))
 122
 123         def _populate_tasks(self, projId):
 124                 if projId in self._items:
 125                         print "SAVED BY THE CACHE"
 126                         return
 127                 self._items[projId] = dict((
 128                         (task["id"], task)
 129                         for task in self._backend.get_tasks_with_details(projId)
 130                 ))
 131                 for taskId, task in self._items[projId].iteritems():
 132                         self._taskIdToProjId[taskId] = task["projId"]
 133                         for noteId, note in task["notes"].iteritems():
 134                                 self._noteIdToTaskId[noteId] = taskId
 135
 136         def _populate_locations(self):
 137                 if self._locations:
 138                         print "SAVED BY THE CACHE"
 139                         return
 140                 self._locations = dict((
 141                         (loc["id"], loc)
 142                         for loc in self._backend.get_locations()
 143                 ))
 144
 145         def _invalidate_projects(self):
 146                 self._projects.clear()
 147
 148         def _invalidate_task(self, taskId):
 149                 projId = self._taskIdToProjId[taskId]
 150                 self._invalidate_projects_tasks(projId)
 151                 self._invalidate_metaprojects_tasks()
 152
 153         def _invalidate_projects_tasks(self, projId):
 154                 del self._items[projId]
 155
 156         def _invalidate_metaprojects_tasks(self):
 157                 for projId in self._get_metalists():
 158                         self._invalidate_projects_tasks(projId)
 159
 160         def _get_metalists(self):
 161                 return (
 162                         list
 163                         for list in self._projects.itervalues()
 164                                 if not list["isMeta"]
 165                 )