+ return t
+
+ def fork_task(self, id_):
+ origin = self.tasks[id_]
+ now = today_date(with_time=True)
+ fork_id = str(uuid4())
+ fork = Task(self, fork_id, {}, {}, {}, {}, origin.comment, id_)
+ self.tasks[fork_id] = fork
+ return fork
+
+ def update_task(self, id_, title, default_effort, tags, fences_adoptions, comment, dep_ids, depender_ids):
+ task = self.tasks[id_] if id_ in self.tasks.keys() else self.add_task(id_)
+ task.title.set(title)
+ task.default_effort.set(default_effort)
+ task.tags.set(tags)
+ task.fences_adoptions.set(fences_adoptions)
+ task.comment = comment
+ task.dep_ids.set(dep_ids)
+ for depender in task.dependers:
+ if not depender.id_ in depender_ids:
+ depender_dep_ids = depender.dep_ids.now
+ depender_dep_ids.remove(task.id_)
+ depender.dep_ids.set(depender_dep_ids)
+ for depender_id in depender_ids:
+ depender = self.tasks[depender_id]
+ depender_dep_ids = depender.dep_ids.now
+ depender_dep_ids.add(task.id_)
+ depender.dep_ids.set(depender_dep_ids)
+ task.loop_check()
+ return task
+
+ def add_todo(self, todo_dict=None, id_=None, task=None, efforts=None, parenthood='', force_new=False, creator=None):
+ make_children = parenthood != 'childless'
+ adopt_if_possible = parenthood == 'adoption'
+ id_ = id_ if id_ else str(uuid4())
+ if todo_dict:
+ todo = Todo.from_dict(self, todo_dict, id_)
+ self.todos[id_] = todo
+ elif task and efforts:
+ todo = Todo(self, id_, task, efforts=efforts)
+ print("DEBUG calling add_todo for", task.title.now, id_)
+ print("debug creator:", creator)
+ self.todos[id_] = todo
+ if creator:
+ creator.deps += [todo]
+ # deps = []
+ if make_children and todo.latest_date in self.days.keys():
+ for dep_task in task.deps:
+ # if Todo expects dependencies, adopt any compatibles found in DB.selected_date
+ # before creating new depended Todos
+ dep_todo = None
+ # if not force_new:
+ if adopt_if_possible:
+ print("debug trying adoption for", dep_task.title.now)
+ # adoptable_todos = [t for t in self.days[todo.latest_date].linked_todos_as_list
+ # if t.task.id_ == dep_task.id_]
+ # if len(adoptable_todos) > 0:
+ # dep_todo = adoptable_todos[0]
+ dep_todo = todo.closest_adoptable(dep_task.id_)
+ print("debug GOT ADOPTION", dep_todo)
+ if not dep_todo:
+ # dep_todo = self.add_todo(task=dep_task, efforts=efforts, force_new)
+ print("debug no adoption for", dep_task.title.now, id_)
+ dep_todo = self.add_todo(task=dep_task, efforts=efforts, parenthood=parenthood, creator=todo)
+ todo.deps += [dep_todo]
+ # deps += [dep_todo]
+ # todo.deps = deps
+ for date in todo.efforts.keys():
+ if date in self.days.keys(): # possibly not all Days have been initialized yet
+ self.days[date].linked_todos_as_list += [todo]
+ return todo
+
+ def _update_todo_shared(self, id_, done, comment, importance):
+ todo = self.todos[id_]
+ todo.done = done
+ todo.comment = comment
+ todo.importance = importance
+ return todo
+
+ def update_todo_for_day(self, id_, date, effort, done, comment, importance):
+ todo = self._update_todo_shared(id_, done, comment, importance)
+ todo.efforts[date] = effort
+
+ def update_todo(self, id_, efforts, done, comment, tags, importance, deps, depender_ids):
+ todo = self._update_todo_shared(id_, done, comment, importance)
+ if len(efforts) == 0 and not todo.deps:
+ raise PlomException('todo must have at least one effort!')
+ todo.efforts = efforts
+ for date in todo.efforts.keys():
+ if not date in self.days.keys():
+ self.add_day(date=date)
+ if not self in self.days[date].linked_todos_as_list:
+ self.days[date].linked_todos_as_list += [todo]
+ todo.day_tags = tags
+ todo.deps = deps
+ for depender_id in depender_ids:
+ depender = self.todos[depender_id]
+ depender.dep_ids.add(todo.id_)
+ for depender in todo.dependers:
+ if not depender.id_ in depender_ids:
+ depender.dep_ids.remove(todo.id_)
+ todo.loop_check()
+
+ def delete_todo(self, id_):
+ todo = self.todos[id_]
+ dates_to_delete = []
+ for date in todo.efforts.keys():
+ dates_to_delete += [date]
+ for date in dates_to_delete:
+ self.delete_effort(todo, date, force=True)
+ for depender in todo.dependers:
+ depender.dep_ids.remove(todo.id_)
+ del self.todos[id_]
+
+ def delete_task(self, id_):
+ del self.tasks[id_]
+
+ def delete_effort(self, todo, date, force=False):
+ if (not force) and len(todo.efforts) == 1:
+ raise PlomException('todo must retain at least one effort!')
+ self.days[date].linked_todos_as_list.remove(todo)
+ del todo.efforts[date]
+
+ # views
+
+ def get_message(self, message):
+ return j2env.get_template('message.html').render(message=message)
+
+ def get_calendar_export(self, start_date_str, end_date_str):
+ days_to_show = self.init_calendar_items(start_date_str, end_date_str)
+ return j2env.get_template('calendar_export.html').render(days=days_to_show)
+
+ def get_calendar(self, start_date_str, end_date_str):
+ days_to_show = self.init_calendar_items(start_date_str, end_date_str)
+ return j2env.get_template('calendar.html').render(
+ selected_date=self.selected_date,
+ days=days_to_show,
+ start_date=start_date_str,
+ end_date=end_date_str)
+
+ def get_day_todos(self, undone_sort_order=None, done_sort_order=None, is_tree_shaped=False, todo_parenthood=None):
+ legal_undone_sort_keys = {'title', 'sort_done', 'default_effort', 'importance'}
+ legal_done_sort_keys = {'title', 'effort_at_selected_date', 'family_effort'}
+
+ current_date = datetime.strptime(self.selected_date, DATE_FORMAT)
+ prev_date = current_date - timedelta(days=1)
+ prev_date_str = prev_date.strftime(DATE_FORMAT)
+ next_date = current_date + timedelta(days=1)
+ next_date_str = next_date.strftime(DATE_FORMAT)
+
+ adoptable_past_todos = []
+ for todo in [t for t in self.todos.values()
+ if t.visible
+ and (not t.done)
+ and t.earliest_date < self.selected_date]:
+ adoptable_past_todos += [todo]
+ undone_todos = self.selected_day.sorted_todos(False, is_tree_shaped, undone_sort_order,
+ legal_undone_sort_keys)
+ done_todos = self.selected_day.sorted_todos(True, is_tree_shaped, done_sort_order,
+ legal_done_sort_keys)
+
+ return j2env.get_template('day_todos.html').render(
+ day=self.selected_day,
+ tags=self.t_tags,
+ filter_and=self.tag_filter_and,
+ filter_not=self.tag_filter_not,
+ prev_date=prev_date_str,
+ adoptable_past_todos=adoptable_past_todos,
+ next_date=next_date_str,
+ all_tasks=[t for t in self.tasks.values()],
+ undone_todos=undone_todos,
+ done_todos=done_todos,
+ is_tree_shaped=is_tree_shaped,
+ undone_sort=undone_sort_order,
+ done_sort=done_sort_order,
+ parenthood=todo_parenthood)
+
+ def get_todo(self, id_, parenthood):
+ todo = self.todos[id_]
+ filtered_tasks = [t for t in self.tasks.values()
+ if t != todo.task]
+ filtered_todos = [t for t in self.todos.values()
+ if t != todo
+ and t not in todo.deps]
+
+ legal_dates = list(todo.efforts.keys())
+ date_filtered_todos = []
+ for date in legal_dates:
+ for filtered_todo in filtered_todos:
+ if filtered_todo in date_filtered_todos:
+ continue
+ if date in filtered_todo.efforts.keys():
+ date_filtered_todos += [filtered_todo]
+
+ dep_slots = []
+ for dep in todo.task.deps:
+ dep_slots += [{'task': dep,
+ 'todos': [t for t in todo.deps if t.task == dep]}]
+
+ suggested_todos = {}
+ for dep in todo.task.deps:
+ suggested_todos[dep.id_] = [t for t in date_filtered_todos if t.task.id_ == dep.id_]
+ additional_deps = [t for t in todo.deps if not t.task in todo.task.deps]
+
+ return j2env.get_template('todo.html').render(
+ tags=self.t_tags,
+ todo=todo,
+ filtered_todos=date_filtered_todos,
+ filtered_tasks=filtered_tasks,
+ dep_slots=dep_slots,
+ suggested_todos=suggested_todos,
+ additional_deps=additional_deps,
+ parentood=parenthood,
+ dep_todos=todo.deps)
+
+ def get_task(self, id_):
+ if id_:
+ if not id_ in self.tasks.keys():
+ raise PlomException('no Task for ID')
+ task = self.tasks[id_]
+ else:
+ task = self.add_task()
+ if not id_:
+ task.default_effort.set(1.0)
+ filtered_tasks = [t for t in self.tasks.values()
+ if t != task
+ and (t not in task.deps)]
+
+ return j2env.get_template('task.html').render(
+ selected_date=self.selected_date,
+ tags=self.t_tags,
+ filtered_tasks=filtered_tasks,
+ task=task)
+
+ def get_tasks(self, search, sort_order=None):
+ filtered_tasks = []
+ for task in [t for t in self.tasks.values() if (not search) or t.matches(search)]:
+ filtered_tasks += [task]
+ reverse = False
+ sort_column = sort_order
+ if sort_order and '-' == sort_order[0]:
+ reverse = True
+ sort_column = sort_order[1:]
+ if sort_column == 'title':
+ filtered_tasks.sort(key=lambda t: t.title.now)
+ elif sort_column == 'default_effort':
+ filtered_tasks.sort(key=lambda t: t.default_effort.now)
+ elif sort_column == 'weight':
+ filtered_tasks.sort(key=lambda t: t.deps_weight)
+ elif sort_column == 'latest_effort_date':
+ filtered_tasks.sort(key=lambda t: t.latest_effort_date)
+ if reverse:
+ filtered_tasks.reverse()
+ return j2env.get_template('tasks.html').render(
+ sort=sort_order,
+ tasks=filtered_tasks,
+ tags=self.t_tags,
+ filter_and=self.tag_filter_and,
+ filter_not=self.tag_filter_not,
+ search=search)
+
+ # posts
+
+ def post_todo(self, id_, postvars, todo_parenthood):
+ if postvars.has('delete') and (not id_ in self.todos.keys()):
+ raise PlomException('can only do this on Todo that already exists')
+ old_todo = self.todos[id_] if id_ in self.todos.keys() else None
+ latest_date = self.selected_date
+ efforts = {}
+ for i, date in enumerate(postvars.get_all('effort_date', [])):
+ if '' == date:
+ continue
+ latest_date = date
+ efforts[date] = postvars.get_at_index('effort', i, float_if_possible=True)
+ if postvars.has('delete'):
+ raise PlomException('can only do this on Task that already exists')
+ has_day_effort = len([e for e in efforts.values() if e is not None]) > 0
+ if postvars.has('done')\
+ or postvars.get('comment')\
+ or postvars.get_all('tag', [])\
+ or has_day_effort:
+ raise PlomException('will not remove todo of preserve-worthy values')
+ self.delete_todo(id_)
+ return False
+ elif postvars.has('update'):
+ if postvars.has('delete_effort'):
+ for date in postvars.get_all('delete_effort'):
+ self.delete_effort(old_todo, date)
+ del efforts[date]
+ deps = [self.todos[adopt_id] for adopt_id in postvars.get_all('adopt_dep', [])
+ if adopt_id in self.todos.keys()]
+ birth_dep_ids = postvars.get_all('birth_dep', [])
+ for bad_id in [bad_id for bad_id in birth_dep_ids if not bad_id in self.tasks.keys()]:
+ raise PlomException('submitted illegal dep ID')
+ tasks_to_birth = [self.tasks[dep_id] for dep_id in birth_dep_ids]
+ for task in tasks_to_birth:
+ deps += [self.add_todo(task=task,
+ efforts={latest_date: None},
+ parenthood=todo_parenthood)]
+ depender_ids = postvars.get_all('depender', [])
+ self.update_todo(id_=id_,
+ efforts=efforts,
+ done=postvars.has('done'),
+ comment=postvars.get('comment', ''),
+ tags=postvars.get_all('tag', []),
+ importance=postvars.get('importance', float_if_possible=True),
+ deps=deps,
+ depender_ids=depender_ids)
+ return True
+
+ def post_task(self, id_, postvars):
+ if (postvars.has('delete') or postvars.has('fork')) and (not id_ in self.tasks.keys()):
+ raise PlomException('can only do this on Task that already exists')
+ if postvars.has('delete'):
+ if [t for t in self.todos.values() if id_ == t.task.id_]:
+ raise PlomException('will not remove Task describing existing Todos')
+ if postvars.get('title', '')\
+ or postvars.get_all('tag', [])\
+ or postvars.get_all('dep', [])\
+ or postvars.get('comment', ''):
+ raise PlomException('will not remove Task of preserve-worthy values')
+ self.delete_task(id_)
+ return None
+ elif postvars.has('update'):
+ dep_ids = postvars.get_all('dep', [])
+ for bad_id in [bad_id for bad_id in dep_ids if not bad_id in self.tasks.keys()]:
+ raise PlomException('submitted illegal dep ID')
+ depender_ids = postvars.get_all('depender', [])
+ for bad_id in [bad_id_ for bad_id in depender_ids if not bad_id in self.tasks.keys()]:
+ raise PlomException('submitted illegal dep ID')
+ task = self.update_task(
+ id_=id_,
+ title=postvars.get('title', ''),
+ default_effort=postvars.get('default_effort', float_if_possible=True),
+ tags=postvars.get_all('tag', []),
+ comment=postvars.get('comment', ''),
+ fences_adoptions=postvars.get('fences_adoptions', False),
+ dep_ids=dep_ids,
+ depender_ids=depender_ids)
+ if postvars.has('add_as_todo'):
+ self.add_todo(task=task, efforts={postvars.get('new_todo_date'): None})
+ elif postvars.has('fork'):
+ t = self.fork_task(id_)
+ return t.id_
+ return id_
+
+ def post_day_todos(self, postvars, todo_parenthood):
+ if not postvars.has('update'):
+ return
+ self.selected_date = postvars.get('date')
+ self.selected_day.comment = postvars.get('day_comment', '')
+ task_id = postvars.get('choose_task', None)
+ if task_id:
+ if task_id not in self.tasks.keys():
+ raise PlomException('illegal task ID entered')
+ self.add_todo(task=self.tasks[task_id], efforts={self.selected_date: None},
+ parenthood=todo_parenthood)
+ for todo_id in postvars.get_all('choose_todo', []):
+ self.todos[todo_id].efforts[self.selected_date] = None
+ for i, todo_id in enumerate(postvars.get_all('todo_id', [])):
+ old_todo = self.todos[todo_id]
+ done = todo_id in postvars.get_all('done', [])
+ day_effort_input = postvars.get_at_index('effort', i, '')
+ day_effort = float(day_effort_input) if len(day_effort_input) > 0 else None
+ comment = postvars.get_at_index('effort_comment', i, '')
+ if (day_effort is not None) and (not done) and day_effort < 0 and 0 == len(comment):
+ if len(old_todo.efforts) > 1:
+ self.delete_effort(old_todo, self.selected_date)
+ else:
+ self.delete_todo(todo_id)
+ continue
+ importance = float(postvars.get_at_index('importance', i))
+ if old_todo\
+ and old_todo.done == done\
+ and old_todo.day_effort == day_effort\
+ and comment == old_todo.comment\
+ and old_todo.importance == importance:
+ continue
+ self.update_todo_for_day(
+ todo_id,
+ self.selected_date,
+ day_effort,
+ done,
+ comment,
+ importance)
+
+ # helpers
+
+ def init_calendar_items(self, start_date_str, end_date_str):
+ self.tag_filter_and = ['calendar']
+ self.tag_filter_not = ['deleted']
+
+ todays_date_obj = datetime.strptime(today_date(), DATE_FORMAT)
+ yesterdays_date_obj = todays_date_obj - timedelta(1)
+ def get_day_limit_obj(index, day_limit_string):
+ date_obj = datetime.strptime(sorted(self.days.keys())[index], DATE_FORMAT)
+ if day_limit_string and len(day_limit_string) > 0:
+ if day_limit_string in {'today', 'yesterday'}:
+ date_obj = todays_date_obj if day_limit_string == 'today' else yesterdays_date_obj
+ else:
+ date_obj = datetime.strptime(day_limit_string, DATE_FORMAT)
+ return date_obj
+ start_date_obj = get_day_limit_obj(0, start_date_str)
+ end_date_obj = get_day_limit_obj(-1, end_date_str)
+
+ days_to_show = {}
+ for n in range(int((end_date_obj - start_date_obj).days) + 1):
+ date_obj = start_date_obj + timedelta(n)
+ date_str = date_obj.strftime(DATE_FORMAT)
+ if date_str not in self.days.keys():
+ days_to_show[date_str] = self.add_day(date_str)
+ else:
+ days_to_show[date_str] = self.days[date_str]
+ days_to_show[date_str].month_title = date_obj.strftime('%B') if date_obj.day == 1 else None
+ days_to_show[date_str].weekday = datetime.strptime(date_str, DATE_FORMAT).strftime('%A')[:2]
+ return days_to_show
+
+
+
+class ParamsParser:
+
+ def __init__(self, parsed_url_query, cookie_db):
+ self.params = parse_qs(parsed_url_query)
+ self.cookie_db = cookie_db
+
+ def get(self, key, default=None, as_bool=False):
+ param = self.params.get(key, [default])[0]
+ if as_bool:
+ if param == '0':
+ param = False
+ elif param is not None:
+ param = True
+ return param
+
+ def cookie_key_from_params_key(self, prefix, key):
+ return f'{prefix}:{key}' if prefix else key
+
+ def _get_cookied(self, cookie_key, params):
+ if params in [['-'], '-']:
+ params = None
+ if cookie_key in self.cookie_db.keys():
+ del self.cookie_db[cookie_key]
+ if params is None and cookie_key in self.cookie_db.keys():
+ params = self.cookie_db[cookie_key]
+ if params is not None:
+ self.cookie_db[cookie_key] = params
+ return params
+
+ def get_cookied(self, key, default=None, prefix=None, as_bool=False):
+ cookie_key = self.cookie_key_from_params_key(prefix, key)
+ param = self.get(key, default, as_bool)
+ return self._get_cookied(cookie_key, param)
+
+ def get_cookied_chain(self, key, default=None, prefix=None):
+ cookie_key = self.cookie_key_from_params_key(prefix, key)
+ params = self.params.get(key, default)
+ return self._get_cookied(cookie_key, params)
+
+
+
+class PostvarsParser: