def _on_menu_file_load(self, _evt):
appconfig = self._appconfig
dlg = wx.FileDialog(self.wnd,
_("Please select sync file."),
defaultDir=appconfig.get('files', 'last_dir', ''),
defaultFile=appconfig.get('files', 'last_file', 'GTD_SYNC.zip'),
style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
if dlg.ShowModal() == wx.ID_OK:
filename = dlg.GetPath()
dlgp = DlgSyncProggress(self.wnd)
dlgp.run()
try:
loader.load_from_file(filename, dlgp.update, force=True)
except Exception as err: # pylint: disable=W0703
_LOG.exception("FrameMain._on_menu_file_load error")
msgdlg = wx.lib.dialogs.ScrolledMessageDialog(self.wnd,
str(err), _("Synchronisation error"))
msgdlg.ShowModal()
msgdlg.Destroy()
dlgp.update(100, _("Error: ") + str(err))
dlgp.mark_finished(2)
appconfig.set('files', 'last_dir', os.path.dirname(filename))
appconfig.set('files', 'last_file', os.path.basename(filename))
publisher.sendMessage('task.update')
dlg.Destroy()
def delete_task(task, session=None, permanently=False):
""" Delete given task.
Show confirmation and delete task from database.
Args:
task: one or list of task for delete (Task or UUID)
session: sqlalchemy session
permanently: if True - delete objects from database
Returns:
True = task deleted
"""
session = session or OBJ.Session()
tasks = task if isinstance(task, (list, tuple)) else [task]
deleted = 0
for task in tasks:
if isinstance(task, (str, unicode)):
task = session.query(OBJ.Task).filter_by(uuid=task).first()
if not task:
_LOG.warning("delete_task: missing task %r", task)
continue
if permanently:
session.delete(task)
else:
task.deleted = datetime.datetime.now()
deleted += 1
if deleted:
session.commit()
publisher.sendMessage("task.delete")
return bool(deleted)
def _on_menu_file_save(self, _evt):
appconfig = self._appconfig
dlg = wx.FileDialog(self.wnd,
_("Please select target sync file."),
defaultDir=appconfig.get('files', 'last_dir', ''),
defaultFile=appconfig.get('files', 'last_file', 'GTD_SYNC.zip'),
style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
if dlg.ShowModal() == wx.ID_OK:
filename = dlg.GetPath()
dlgp = DlgSyncProggress(self.wnd)
dlgp.run()
try:
exporter.save_to_file(filename, dlgp.update)
except Exception as err: # pylint: disable=W0703
_LOG.exception('FrameMain._on_menu_file_save error')
msgdlg = wx.lib.dialogs.ScrolledMessageDialog(self.wnd,
str(err), _("Synchronisation error"))
msgdlg.ShowModal()
msgdlg.Destroy()
dlgp.update(100, _("Error: ") + str(err))
dlgp.mark_finished(2)
publisher.sendMessage('task.update')
appconfig.set('files', 'last_dir', os.path.dirname(filename))
appconfig.set('files', 'last_file', os.path.basename(filename))
dlg.Destroy()
def _on_task_btn_dismiss(self, evt):
task_uuid = evt.task
task = OBJ.Task.get(self._session, uuid=task_uuid)
task.alarm = None
task.update_modify_time()
self._session.commit()
publisher.sendMessage('task.update', data={'task_uuid': task.uuid})
def quick_task(parent_wnd=None):
""" Show dialog for quickly adding task. """
dlg = wx.TextEntryDialog(parent_wnd, _("Enter task title"),
_("wxGTD Quick Task"), "")
if dlg.ShowModal() == wx.ID_OK and dlg.GetValue().strip():
task = quicktask.create_quicktask(dlg.GetValue().strip())
publisher.sendMessage('task.update', data={'task_uuid': task.uuid})
dlg.Destroy()
def _autosync(self, on_load=True):
if not self._appconfig.get('sync', 'use_dropbox'):
# don't sync if file is not configured
if not self._appconfig.get('files', 'last_sync_file'):
return
self._synchronize(on_load, autoclose=True)
if on_load:
publisher.sendMessage('task.update')
publisher.sendMessage('dict.update')
def _check_folder_selection(self):
choice_ctrl = self['cb_folder']
if choice_ctrl.GetSelection() >= 0:
# selected known / existing item
return
value = choice_ctrl.GetValue().strip()
if not value:
# nothing selected (default) - ok
return
folder = logic_dicts.find_or_create_folder(value, self._session)
if folder:
self._task.folder = folder
publisher.sendMessage('dict.update')
def _on_save(self, _evt):
""" Save selected & edited item. """
if not self._displayed_item:
return
if not self._wnd.Validate():
return
if not self._wnd.TransferDataFromWindow():
return
self._displayed_item.update_modify_time()
self._session.add(self._displayed_item) # pylint: disable=E1101
self._session.commit() # pylint: disable=E1101
self._refresh_list()
publisher.sendMessage('dict.update')
def handle(self):
data = self.request.recv(1024).strip()
_LOG.info("_ThreadedTCPRequestHandler.handle(%r)", data)
try:
if data == "check":
self.request.sendall("ok")
return
data_j = _JSON_DECODER(data.decode("UTF-8"))
message = data_j['message']
publisher.sendMessage(message, data=data_j.get("data"))
self.request.sendall("ok")
except Exception as err: # pylint: disable=W0703
print err
def _check_context_selection(self):
choice_ctrl = self['cb_context']
if choice_ctrl.GetSelection() >= 0:
# selected known / existing item
return
value = choice_ctrl.GetValue().strip()
if not value:
# nothing selected (default) - ok
return
context = logic_dicts.find_or_create_context(value, self._session)
if context:
self._task.context = context
publisher.sendMessage('dict.update')
def _check_goal_selection(self):
choice_ctrl = self['cb_goal']
if choice_ctrl.GetSelection() >= 0:
# selected known / existing item
return
value = choice_ctrl.GetValue().strip()
if not value:
# nothing selected (default) - ok
return
goal = logic_dicts.find_or_create_goal(value, self._session)
if goal:
self._task.goal = goal
publisher.sendMessage('dict.update')
def _on_task_btn_snooze(self, evt):
task_uuid = evt.task
dlg = wx.SingleChoiceDialog(self.wnd, _("Please select snooze time"),
_("Snooze task alarm"),
[pattern[1] for pattern in enums.SNOOZE_PATTERNS],
wx.CHOICEDLG_STYLE)
if dlg.ShowModal() == wx.ID_OK:
pattern = enums.SNOOZE_PATTERNS[dlg.GetSelection()][0]
task = OBJ.Task.get(self._session, uuid=task_uuid)
task.alarm = datetime.utcnow() + task_logic.alarm_pattern_to_time(pattern)
task.update_modify_time()
self._session.commit()
publisher.sendMessage('task.update', data={'task_uuid': task.uuid})
dlg.Destroy()
def save_modified_page(page, session=None):
""" Save modified notebook page.
Update required fields.
Args:
page: page to save
session: optional SqlAlchemy session
Returns:
True if ok.
"""
session = session or OBJ.Session()
page.update_modify_time()
session.add(page)
session.commit()
publisher.sendMessage('notebook.update', data={'notebook_uuid': page.uuid})
return True
def find_or_create_folder(title, session):
""" Find folder with given title, if not found - create it.
Args:
title: title of folder
session: SqlAlchemy session
Returns:
Folder object
"""
folder = obj.Folder.get(session, title=title)
if not folder:
_LOG.debug('find_or_create_folder: creating folder from title=%r',
title)
folder = obj.Folder(title=title)
session.add(folder)
publisher.sendMessage('folder.update')
return folder
def find_or_create_goal(title, session):
""" Find goal with given title, if not found - create it.
Args:
title: title of goal
session: SqlAlchemy session
Returns:
Goal object
"""
goal = obj.Goal.get(session, title=title)
if not goal:
_LOG.debug('find_or_create_goal: creating goal from title=%r',
title)
goal = obj.Goal(title=title)
session.add(goal)
publisher.sendMessage('goal.update')
return goal
def clone_task(task_uuid, session=None):
""" Clone task.
Args:
task_uuid: task to clone
session: optional SqlAlchemy session
Returns:
Cloned task UUID or None when error.
"""
session = session or OBJ.Session()
task = session.query(OBJ.Task).filter_by(uuid=task_uuid).first()
if not task:
_LOG.warn("_clone_selected_task; missing task %r", task_uuid)
return None
new_task = task.clone()
save_modified_task(new_task, session)
publisher.sendMessage("task.update", data={"task_uuid": new_task.uuid})
return new_task.uuid
def find_or_create_context(title, session):
""" Find context with given title, if not found - create it.
Args:
title: title of context
session: SqlAlchemy session
Returns:
Context object
"""
context = obj.Context.get(session, title=title)
if not context:
_LOG.debug('find_or_create_context: creating context from title=%r',
title)
context = obj.Context(title=title)
session.add(context)
publisher.sendMessage('context.update')
return context
def undelete_dict_item(item, session):
""" Undelete given item.
Args:
item: item to undelete
session: SqlAlchemy session
Returns:
True if ok
"""
if item.deleted:
_LOG.info("undelete_dict_item: %r", item)
item.deleted = None
item.modified = datetime.datetime.now()
session.commit()
publisher.sendMessage('dictitem.update')
return True
_LOG.warn("undelete_dict_item: undelete not deleted object: %r", item)
return False
def delete_notebook_page(page_uuid, session=None):
""" Delete given notebook page.
Show confirmation and delete page from database.
Args:
page_uuid: notebook page for delete
session: sqlalchemy session
Returns:
True = task deleted
"""
session = session or OBJ.Session()
page = session.query(OBJ.NotebookPage).filter_by(uuid=page_uuid).first()
if not page:
_LOG.warning("delete_notebook_page: missing page %r", page_uuid)
return False
page.deleted = datetime.datetime.now()
session.commit()
publisher.sendMessage('notebook.delete', data={'notebook_uuid': page_uuid})
return True
def _on_del_item(self, _evt):
""" Acton for delete item button. """
sel = self._selected_item_uuid
if sel is None:
return
item = self._get_item(sel)
if not item:
return
additional_info = None
if self._check_children_before_delete(item):
additional_info = (_('After removal, it cannot be recovered.')
+ "\n\n"
+ _("Warning: this affect another items!"))
if mbox.message_box_delete_confirm(self._wnd, self._item_name + ' "' +
item.title + '"', additional_info):
if hasattr(item, 'deleted'):
item.deleted = datetime.datetime.now()
else:
self._session.delete(item) # pylint: disable=E1101
self._session.commit() # pylint: disable=E1101
self._refresh_list()
publisher.sendMessage('dict.delete')
return True
def save_modified_task(task, session=None):
""" Save modified task.
Update required fields.
Args:
task: task to save
session: optional SqlAlchemy session
Returns:
True if ok.
"""
session = session or OBJ.Session()
update_task_hide(task)
update_task_alarm(task)
adjust_task_type(task, session)
update_project_due_date(task)
if task.type == enums.TYPE_CHECKLIST_ITEM:
if not task.importance:
task.importance = OBJ.Task.find_max_importance(task.parent_uuid, session) + 1
task.update_modify_time()
session.add(task)
session.commit() # pylint: disable=E1101
publisher.sendMessage("task.update", data={"task_uuid": task.uuid})
return True
def _on_menu_file_sync(self, _evt):
self._synchronize(False)
publisher.sendMessage('task.update')
publisher.sendMessage('dict.update')
def _notify_progress(progress, msg):
publisher.sendMessage('sync.progress', data=(progress, msg))
