def _save_to_fs(self, data): _data = copy.deepcopy(data, {}) del _data['categories'] if data.has_key('categories') and data['categories']: _cat = [{'category': x} for x in data['categories']] _data['categories'] = _cat del _data['start'] if data.has_key('start') and data['start']: _date = [{ 'year': data['start'][0], 'month': data['start'][1], 'day': data['start'][2] }] _data['start'] = _date del _data['end'] if data.has_key('end') and data['end']: _date = [{ 'year': data['end'][0], 'month': data['end'][1], 'day': data['end'][2] }] _data['end'] = _date _dict = {'filter': _data} database.ensurerecordtype(_dict, filterobjectfactory) self.GetParent().GetParent().GetActiveDatabase().savemajordict( 'calendar_filter', _dict)
def _save_to_fs(self): _data = {} for _key, _entry in self._data.items(): _entry.validate_properties() _data[_key] = self._expand_item(_entry) database.ensurerecordtype(_data, importcalendarobjectfactory) self._parent.GetActiveDatabase().savemajordict('imp_cal_preset', _data)
def getfromfs(self, dict): """Updates dict with info from disk @Note: The dictionary passed in is modified, as well as returned @rtype: dict @param dict: the dictionary to update @return: the updated dictionary""" self.thedir=self.mainwindow.calendarpath if os.path.exists(os.path.join(self.thedir, "index.idx")): dct={'result': {}} common.readversionedindexfile(os.path.join(self.thedir, "index.idx"), dct, self.versionupgrade, self.CURRENTFILEVERSION) converted=dct['result'].has_key('converted') db_r={} for k,e in dct['result'].get('calendar', {}).items(): if converted: db_r[k]=CalendarDataObject(e) else: ce=CalendarEntry() ce.set(e) db_r[k]=CalendarDataObject(ce) database.ensurerecordtype(db_r, calendarobjectfactory) db_r=database.extractbitpimserials(db_r) self.mainwindow.database.savemajordict('calendar', db_r) os.rename(os.path.join(self.thedir, "index.idx"), os.path.join(self.thedir, "index-is-now-in-database.bak")) cal_dict=self.mainwindow.database.getmajordictvalues('calendar', calendarobjectfactory) r={} for k,e in cal_dict.items(): ce=CalendarEntry() ce.set_db_dict(e) r[ce.id]=ce dict.update({ 'calendar': r }) return dict
def _save_to_db(self, todo_dict): db_rr={} for k, e in todo_dict.items(): db_rr[k]=TodoDataObject(e) database.ensurerecordtype(db_rr, todoobjectfactory) self._main_window.database.savemajordict('todo', db_rr) self._publish_today_events() self._publish_thisweek_events()
def _save_to_db(self, dict): if self.read_only: return db_rr = {} for k, e in dict.items(): db_rr[k] = CallHistoryDataobject(e) database.ensurerecordtype(db_rr, callhistoryobjectfactory) self._main_window.database.savemajordict(self._data_key, db_rr)
def _save_to_fs(self): _data={} for _key, _entry in self._data.items(): _entry.validate_properties() _data[_key]=self._expand_item(_entry) database.ensurerecordtype(_data, importcalendarobjectfactory) self._parent.GetActiveDatabase().savemajordict('imp_cal_preset', _data)
def _save_to_db(self, dict): if self.read_only: return db_rr={} for k,e in dict.items(): db_rr[k]=CallHistoryDataobject(e) database.ensurerecordtype(db_rr, callhistoryobjectfactory) self._main_window.database.savemajordict(self._data_key, db_rr)
def _save_to_db(self, todo_dict): db_rr = {} for k, e in todo_dict.items(): db_rr[k] = TodoDataObject(e) database.ensurerecordtype(db_rr, todoobjectfactory) self._main_window.database.savemajordict('todo', db_rr) self._publish_today_events() self._publish_thisweek_events()
def _save_to_db(self): db_rr={} self.settings.caltype=self.caltype.GetValue() self.settings.sync_on_connect=self.sync_on_connect.GetValue() self.settings.sync_frequency=self.sync_frequency.GetValue() self.settings.id=self.profile db_rr[self.settings.id]=AutoSyncSettingsobject(self.settings) database.ensurerecordtype(db_rr, autosyncsettingsobjectfactory) self.mw.tree.GetActivePhone().GetDatabase().savemajordict(_data_key, db_rr)
def save(self, db): # save the current list to the database db global dict_key _rec=[] for _,_list in self._data.items(): _rec+=[ { 'word': x } for x in _list ] _dict={ dict_key: { 'words': _rec } } database.ensurerecordtype(_dict, t9wordsdataobjectfactory) db.savemajordict(dict_key, _dict)
def _save_to_db(self): db_rr = {} self.settings.caltype = self.caltype.GetValue() self.settings.sync_on_connect = self.sync_on_connect.GetValue() self.settings.sync_frequency = self.sync_frequency.GetValue() self.settings.id = self.profile db_rr[self.settings.id] = AutoSyncSettingsobject(self.settings) database.ensurerecordtype(db_rr, autosyncsettingsobjectfactory) self.mw.tree.GetActivePhone().GetDatabase().savemajordict( _data_key, db_rr)
def _save_to_db(self, dict): db_rr={} for k,e in dict.items(): db_rr[k]=MediaDataObject(e) if db_rr[k].has_key('mediadata'): md5_sum=md5.new(db_rr[k]['mediadata']).hexdigest() fname=os.path.join(self.mainwindow.blob_path, md5_sum) f=open(fname, "wb") f.write(db_rr[k]['mediadata']) f.close() db_rr[k]['mediadata']=md5_sum database.ensurerecordtype(db_rr, mediaobjectfactory) self.mainwindow.database.savemajordict(self.database_key, db_rr)
def populatefs(self, dict): """Saves the dict to disk""" if dict.get('calendar_version', None)==2: cal_dict=self._convert2to3(dict.get('calendar', {}), dict.get('ringtone-index', {})) else: cal_dict=dict.get('calendar', {}) db_rr={} for k, e in cal_dict.items(): db_rr[k]=CalendarDataObject(e) database.ensurerecordtype(db_rr, calendarobjectfactory) db_rr=database.extractbitpimserials(db_rr) self.mainwindow.database.savemajordict('calendar', db_rr) return dict
def _save_to_db(self, sms_dict=None, canned_msg_dict=None): if self.read_only: return if sms_dict is not None: db_rr = {} for k, e in sms_dict.items(): db_rr[k] = sms.SMSDataObject(e) database.ensurerecordtype(db_rr, sms.smsobjectfactory) self._main_window.database.savemajordict(self._data_key, db_rr) if canned_msg_dict is not None: db_rr = {} db_rr[self._canned_data_key] = sms.CannedMsgDataObject( canned_msg_dict) database.ensurerecordtype(db_rr, sms.cannedmsgobjectfactory) self._main_window.database.savemajordict(self._canned_data_key, db_rr)
def _save_to_db(self, sms_dict=None, canned_msg_dict=None): if self.read_only: return if sms_dict is not None: db_rr={} for k, e in sms_dict.items(): db_rr[k]=sms.SMSDataObject(e) database.ensurerecordtype(db_rr, sms.smsobjectfactory) self._main_window.database.savemajordict(self._data_key, db_rr) if canned_msg_dict is not None: db_rr={} db_rr[self._canned_data_key]=sms.CannedMsgDataObject( canned_msg_dict) database.ensurerecordtype(db_rr, sms.cannedmsgobjectfactory) self._main_window.database.savemajordict(self._canned_data_key, db_rr)
def _save_to_fs(self, data): _data=copy.deepcopy(data, {}) del _data['categories'] if data.has_key('categories') and data['categories']: _cat=[{'category': x} for x in data['categories'] ] _data['categories']=_cat del _data['start'] if data.has_key('start') and data['start']: _date=[{'year': data['start'][0], 'month': data['start'][1], 'day': data['start'][2] }] _data['start']=_date del _data['end'] if data.has_key('end') and data['end']: _date=[{'year': data['end'][0], 'month': data['end'][1], 'day': data['end'][2] }] _data['end']=_date _dict={ 'filter': _data } database.ensurerecordtype(_dict, filterobjectfactory) self.GetParent().GetParent().database.savemajordict('calendar_filter', _dict)
def _save_to_db(self, dict): db_rr={} for k,e in dict.items(): db_rr[k]=MediaDataObject(e) if db_rr[k].has_key('mediadata'): dir_name=os.path.join(self.mainwindow.blob_path, db_rr[k]['origin']) try: os.makedirs(dir_name) except: pass if not os.path.isdir(dir_name): raise Exception("Unable to create media directory "+dir_name) relative_name=os.path.join(db_rr[k]['origin'], db_rr[k]['name']) fname=os.path.join(self.mainwindow.blob_path, relative_name) f=open(fname, "wb") f.write(db_rr[k]['mediadata']) f.close() db_rr[k]['mediadata']=relative_name database.ensurerecordtype(db_rr, mediaobjectfactory) self.mainwindow.database.savemajordict(self.database_key, db_rr)
def _save_to_db(self, dict): db_rr={ masterlist_key: MasterListDataObject(dict.get(masterlist_key, [])) } database.ensurerecordtype(db_rr, masterlistobjectfactory) self._mw.database.savemajordict(masterlist_key, db_rr) _pl_list=dict.get(playlist_key, []) db_rr={ playlists_list: PlaylistDataObject([x.name for x in _pl_list]) } database.ensurerecordtype(db_rr, playlistobjectfactory) self._mw.database.savemajordict(playlists_list, db_rr) db_rr={ } for e in _pl_list: db_rr[e.name]=PlaylistEntryDataObject(e) database.ensurerecordtype(db_rr, playlistentryobjectfactory) self._mw.database.savemajordict(playlist_key, db_rr)
def _save_to_db(self, dict): # first, save the master list of songs. db_rr={ masterlist_key: MasterListDataObject(dict.get(masterlist_key, [])) } database.ensurerecordtype(db_rr, masterlistobjectfactory) self._mw.database.savemajordict(masterlist_key, db_rr) # now, save the list of playlists _pl_list=dict.get(playlist_key, []) db_rr={ playlists_list: PlaylistDataObject([x.name for x in _pl_list]) } database.ensurerecordtype(db_rr, playlistobjectfactory) self._mw.database.savemajordict(playlists_list, db_rr) # save the playlist entries db_rr={ } for e in _pl_list: db_rr[e.name]=PlaylistEntryDataObject(e) database.ensurerecordtype(db_rr, playlistentryobjectfactory) self._mw.database.savemajordict(playlist_key, db_rr)
def _save_to_db(self): db_rr={} self.settings.caltype=self.caltype.GetValue() self.settings.sync_on_connect=self.sync_on_connect.GetValue() self.settings.sync_frequency=self.sync_frequency.GetValue() self.settings.id=self.profile db_rr[self.settings.id]=AutoSyncSettingsobject(self.settings) database.ensurerecordtype(db_rr, autosyncsettingsobjectfactory) self.mw.tree.GetActivePhone().GetDatabase().savemajordict(_data_key, db_rr) def getfromfs(self): self.settings=_getsettings(self.mw, self.profile) self.caltype.SetValue(self.settings.caltype) self.sync_on_connect.SetValue(int(self.settings.sync_on_connect)) self.sync_frequency.SetValue(int(self.settings.sync_frequency)) return def IsConfigured(self): return self.settings.caltype!='None' def updatevariables(self): self.mw.auto_save_dict=self.settings def ShowModal(self): self.getfromfs() ec=wx.Dialog.ShowModal(self) if ec==wx.ID_OK: self._save_to_db() self.updatevariables() self.SetAutoSyncTimer() return ec def saveSize(self): guiwidgets.save_size("AutoSyncSettingsDialog", self.GetRect()) def SetAutoSyncTimer(self): self.auto_sync_timer.Stop() oneShot = True timeout=self.settings.sync_frequency*60000 if timeout: self.auto_sync_timer.Start(timeout, oneShot) self.Bind(wx.EVT_TIMER, self.OnTimer, self.auto_sync_timer) def OnTimer(self, event): self.mw.log("Auto Sync: Timed update") SyncSchedule(self.mw).sync(self.mw, silent=1) self.SetAutoSyncTimer()
def _save_to_db(self, dict): if self.read_only: return db_rr={} for k,e in dict.items(): db_rr[k]=CallHistoryDataobject(e) database.ensurerecordtype(db_rr, callhistoryobjectfactory) self._main_window.database.savemajordict(self._data_key, db_rr) def populatefs(self, dict): if self.read_only: wx.MessageBox('You are viewing historical data which cannot be changed or saved', 'Cannot Save Call History Data', style=wx.OK|wx.ICON_ERROR) else: self._save_to_db(dict.get(self._data_key, {})) return dict def getfromfs(self, result, timestamp=None): dict=self._main_window.database.\ getmajordictvalues(self._data_key, callhistoryobjectfactory, at_time=timestamp) r={} for k,e in dict.items(): ce=CallHistoryEntry() ce.set_db_dict(e) r[ce.id]=ce result.update({ self._data_key: r}) return result def merge(self, dict): if self.read_only: wx.MessageBox('You are viewing historical data which cannot be changed or saved', 'Cannot Save Call History Data', style=wx.OK|wx.ICON_ERROR) return d=dict.get(self._data_key, {}) l=[e for k,e in self._data.items()] for k,e in d.items(): if e not in l: self._data[e.id]=e self._save_to_db(self._data) self._populate() def OnHistoricalData(self): """Display current or historical data""" if self.read_only: current_choice=guiwidgets.HistoricalDataDialog.Historical_Data else: current_choice=guiwidgets.HistoricalDataDialog.Current_Data dlg=guiwidgets.HistoricalDataDialog(self, current_choice=current_choice, historical_date=self.historical_date, historical_events=\ self._main_window.database.getchangescount(self._data_key)) if dlg.ShowModal()==wx.ID_OK: self._main_window.OnBusyStart() current_choice, self.historical_date=dlg.GetValue() r={} if current_choice==guiwidgets.HistoricalDataDialog.Current_Data: self.read_only=False msg_str='Current Data' self.getfromfs(r) else: self.read_only=True msg_str='Historical Data as of %s'%\ str(wx.DateTimeFromTimeT(self.historical_date)) self.getfromfs(r, self.historical_date) self.populate(r, True) self.historical_data_label.SetLabel(msg_str) self._main_window.OnBusyEnd() dlg.Destroy() def get_selected_data(self): res={} for sel_idx in self._item_list.GetSelections(): k=self._item_list.GetPyData(sel_idx) if k: res[k]=self._data[k] return res def get_data(self): return self._data
def _save_to_db(self, todo_dict): db_rr={} for k, e in todo_dict.items(): db_rr[k]=TodoDataObject(e) database.ensurerecordtype(db_rr, todoobjectfactory) self._main_window.database.savemajordict('todo', db_rr) self._publish_today_events() self._publish_thisweek_events() def populatefs(self, dict): self._save_to_db(dict.get('todo', {})) return dict def getfromfs(self, result): todo_dict=self._main_window.database.\ getmajordictvalues('todo',todoobjectfactory) r={} for k,e in todo_dict.items(): ce=TodoEntry() ce.set_db_dict(e) r[ce.id]=ce result.update({ 'todo': r }) return result def _OnListBoxItem(self, evt): self._populate_each(self._item_list.GetClientData(evt.GetInt())) self.Refresh() def _OnSave(self, evt): self.ignoredirty=True sel_idx=self._item_list.GetSelection() k=self._item_list.GetClientData(sel_idx) entry=self._data[k] self._general_editor_w.Get(entry) entry.note=self._memo_editor_w.Get().get('memo', None) entry.categories=self._cat_editor_w.Get() entry.check_completion() self._general_editor_w.Set(entry) self._item_list.SetString(sel_idx, entry.summary) self._save_to_db(self._data) self.ignoredirty=False self.setdirty(False) def _OnRevert(self, evt): self.ignoredirty=True sel_idx=self._item_list.GetSelection() k=self._item_list.GetClientData(sel_idx) self._populate_each(k) self.ignoredirty=False self.setdirty(False)
def _save_to_fs(self, data): _dict = {URLDictKey: {'urls': data}} database.ensurerecordtype(_dict, urlobjectfactory) self._db.savemajordict(URLDictName, _dict)
def _save_to_db(self, dict): db_rr={ masterlist_key: MasterListDataObject(dict.get(masterlist_key, [])) } database.ensurerecordtype(db_rr, masterlistobjectfactory) self._mw.database.savemajordict(masterlist_key, db_rr) _pl_list=dict.get(playlist_key, []) db_rr={ playlists_list: PlaylistDataObject([x.name for x in _pl_list]) } database.ensurerecordtype(db_rr, playlistobjectfactory) self._mw.database.savemajordict(playlists_list, db_rr) db_rr={ } for e in _pl_list: db_rr[e.name]=PlaylistEntryDataObject(e) database.ensurerecordtype(db_rr, playlistentryobjectfactory) self._mw.database.savemajordict(playlist_key, db_rr) def populatefs(self, dict): self._save_to_db(dict) return dict def getfromfs(self, result): _master_dict=self._mw.database.getmajordictvalues(masterlist_key, masterlistobjectfactory) _master_dict=_master_dict.get(masterlist_key, {}) result.update( { masterlist_key: \ [x['name'] for x in _master_dict.get(masterlist_key, [])] }) _pl_list_dict=self._mw.database.getmajordictvalues(playlists_list, playlistobjectfactory) _pl_list_dict=_pl_list_dict.get(playlists_list, {}) _pl_entries_dict=self._mw.database.getmajordictvalues(playlist_key, playlistentryobjectfactory) _pl_list=[] for e in _pl_list_dict.get(playlist_key, []): _pl_entry=_pl_entries_dict.get(e['name'], None) if _pl_entry: _entry=PlaylistEntry() _entry.name=e['name'] _entry.type=_pl_entry['type'] _entry.songs=[x['name'] for x in _pl_entry['songs']] _pl_list.append(_entry) result.update({playlist_key: _pl_list }) return result def OnMakeDirty(self, _=None): """A public function you can call that will set the dirty flag""" if self.dirty or self.ignoredirty: return print 'OnMakeDirty' self.setdirty(True) def OnPlaylistSelected(self, evt): self._populate_each(evt.GetLabel()) evt.Skip() def OnDirty(self, _): self.setdirty(True) def _change_playlist_name(self, new_name): for e in self._data: if e.name==self._old_name: e.name=new_name def _add_playlist_name(self, new_name): _entry=PlaylistEntry() _entry.name=new_name self._data.append(_entry) def OnStartLabelChanged(self, evt): self._old_name=evt.GetLabel() def OnLabelChanged(self, evt): _new_name=evt.GetLabel() if _new_name: self.setdirty(True) if self._old_name: self._change_playlist_name(_new_name) else: self._add_playlist_name(_new_name) evt.Skip() def OnAdd2Playlist(self, _): _pl_idx=self._item_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED) _master_idx=self._master_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED) if _pl_idx==-1 or _master_idx==-1: return _entry_idx=self._name2idx(self._item_list_w.GetItemText(_pl_idx)) if _entry_idx is not None: self.setdirty(True) self._pl_list.SetStrings(self._pl_list.GetStrings()+\ [self._master_list_w.GetItemText(_master_idx)]) def _build_playlist(self): _pl_list=[] for _name in self._item_list.GetStrings(): if _name: _idx=self._name2idx(_name) if _idx is not None: _pl_list.append(self._data[_idx]) return _pl_list def OnSave(self, _): _pl_idx=self._item_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED) if _pl_idx!=-1: _entry_idx=self._name2idx(self._item_list_w.GetItemText(_pl_idx)) if _entry_idx is not None: self._data[_entry_idx].songs=self._pl_list.GetStrings() self._save_to_db({ masterlist_key: self._master_list.GetStrings(), playlist_key: self._build_playlist() }) self.setdirty(False) def OnRevert(self, _): _pl_idx=self._item_list_w.GetNextItem(-1, state=wx.LIST_STATE_SELECTED) _res={} self.getfromfs(_res) self.populate(_res) if _pl_idx!=-1: self._item_list_w.SetItemState(_pl_idx, wx.LIST_STATE_SELECTED, wx.LIST_MASK_STATE) self.setdirty(False) def getdata(self, dict): dict[masterlist_key]=self._master_list.GetStrings() dict[playlist_key]=self._build_playlist() return dict
def _save_to_db(self, sms_dict=None, canned_msg_dict=None): if self.read_only: return if sms_dict is not None: db_rr={} for k, e in sms_dict.items(): db_rr[k]=sms.SMSDataObject(e) database.ensurerecordtype(db_rr, sms.smsobjectfactory) self._main_window.database.savemajordict(self._data_key, db_rr) if canned_msg_dict is not None: db_rr={} db_rr[self._canned_data_key]=sms.CannedMsgDataObject( canned_msg_dict) database.ensurerecordtype(db_rr, sms.cannedmsgobjectfactory) self._main_window.database.savemajordict(self._canned_data_key, db_rr) def populatefs(self, dict): if self.read_only: wx.MessageBox('You are viewing historical data which cannot be changed or saved', 'Cannot Save SMS Data', style=wx.OK|wx.ICON_ERROR) return canned_msg=sms.CannedMsgEntry() canned_msg.set({ self._canned_data_key: dict.get(self._canned_data_key, [])}) self._save_to_db(sms_dict=dict.get(self._data_key, []), canned_msg_dict=canned_msg) return dict def getfromfs(self, result, timestamp=None): sms_dict=self._main_window.database.\ getmajordictvalues(self._data_key, sms.smsobjectfactory, at_time=timestamp) r={} for k,e in sms_dict.items(): ce=sms.SMSEntry() ce.set_db_dict(e) r[ce.id]=ce result.update({ self._data_key: r }) canned_msg_dict=self._main_window.database.\ getmajordictvalues(self._canned_data_key, sms.cannedmsgobjectfactory) for k,e in canned_msg_dict.items(): ce=sms.CannedMsgEntry() ce.set_db_dict(e) result.update(ce.get()) return result def merge(self, dict): if self.read_only: wx.MessageBox('You are viewing historical data which cannot be changed or saved', 'Cannot Save SMS Data', style=wx.OK|wx.ICON_ERROR) return existing_id=[e.msg_id for k,e in self._data.items()] d=dict.get(self._data_key, {}) for k,e in d.items(): if e.msg_id not in existing_id: self._data[e.id]=e self._canned_data=sms.CannedMsgEntry() self._canned_data.set({ self._canned_data_key: dict.get(self._canned_data_key, []) } ) self._populate() self._save_to_db(sms_dict=self._data, canned_msg_dict=self._canned_data) def OnHistoricalData(self): """Display current or historical data""" if self.read_only: current_choice=guiwidgets.HistoricalDataDialog.Historical_Data else: current_choice=guiwidgets.HistoricalDataDialog.Current_Data dlg=guiwidgets.HistoricalDataDialog(self, current_choice=current_choice, historical_date=self.historical_date, historical_events=\ self._main_window.database.getchangescount(self._data_key)) if dlg.ShowModal()==wx.ID_OK: self._main_window.OnBusyStart() current_choice, self.historical_date=dlg.GetValue() r={} if current_choice==guiwidgets.HistoricalDataDialog.Current_Data: self.read_only=False msg_str='Current Data' self.getfromfs(r) else: self.read_only=True msg_str='Historical Data as of %s'%\ str(wx.DateTimeFromTimeT(self.historical_date)) self.getfromfs(r, self.historical_date) self.populate(r, True) self.historical_data_label.SetLabel(msg_str) self._main_window.OnBusyEnd() dlg.Destroy()
def _save_to_db(self, memo_dict): db_rr = {} for k, e in memo_dict.items(): db_rr[k] = MemoDataObject(e) database.ensurerecordtype(db_rr, memoobjectfactory) self._main_window.database.savemajordict('memo', db_rr)
def getfromfs(self, dict): """Updates dict with info from disk @Note: The dictionary passed in is modified, as well as returned @rtype: dict @param dict: the dictionary to update @return: the updated dictionary""" self.thedir=self.mainwindow.calendarpath if os.path.exists(os.path.join(self.thedir, "index.idx")): dct={'result': {}} common.readversionedindexfile(os.path.join(self.thedir, "index.idx"), dct, self.versionupgrade, self.CURRENTFILEVERSION) converted=dct['result'].has_key('converted') db_r={} for k,e in dct['result'].get('calendar', {}).items(): if converted: db_r[k]=CalendarDataObject(e) else: ce=CalendarEntry() ce.set(e) db_r[k]=CalendarDataObject(ce) database.ensurerecordtype(db_r, calendarobjectfactory) db_r=database.extractbitpimserials(db_r) self.mainwindow.database.savemajordict('calendar', db_r) os.rename(os.path.join(self.thedir, "index.idx"), os.path.join(self.thedir, "index-is-now-in-database.bak")) cal_dict=self.mainwindow.database.getmajordictvalues('calendar', calendarobjectfactory) r={} for k,e in cal_dict.items(): ce=CalendarEntry() ce.set_db_dict(e) r[ce.id]=ce dict.update({ 'calendar': r }) return dict def versionupgrade(self, dict, version): """Upgrade old data format read from disk @param dict: The dict that was read in @param version: version number of the data on disk """ if version==0: version=1 if version==1: version=2 for k in dict['result']['calendar']: entry=dict['result']['calendar'][k] entry['daybitmap']=self.getdaybitmap(entry['start'], entry['repeat']) del entry['?d'] if version==2: version=3 dict['result']['calendar']=self.convert_dict(dict['result'].get('calendar', {}), 2, 3) dict['result']['converted']=True def convert_dict(self, dict, from_version, to_version, ringtone_index={}): """ Convert the calendatr dict from one version to another. Currently only support conversion between version 2 and 3. """ if dict is None: return None if from_version==2 and to_version==3: return self._convert2to3(dict, ringtone_index) elif from_version==3 and to_version==2: return self._convert3to2(dict, ringtone_index) else: raise 'Invalid conversion' def _convert2to3(self, dict, ringtone_index): """ Convert calendar dict from version 2 to 3. """ r={} for k,e in dict.items(): ce=CalendarEntry() ce.start=e['start'] ce.end=e['end'] ce.description=e['description'] ce.alarm=e['alarm'] ce.ringtone=ringtone_index.get(e['ringtone'], {}).get('name', '') repeat=e['repeat'] if repeat is None: ce.repeat=None else: repeat_entry=RepeatEntry() if repeat=='daily': repeat_entry.repeat_type=repeat_entry.daily repeat_entry.interval=1 elif repeat=='monfri': repeat_entry.repeat_type=repeat_entry.daily repeat_entry.interval=0 elif repeat=='weekly': repeat_entry.repeat_type=repeat_entry.weekly repeat_entry.interval=1 dow=datetime.date(*e['start'][:3]).isoweekday()%7 repeat_entry.dow=1<<dow elif repeat=='monthly': repeat_entry.repeat_type=repeat_entry.monthly else: repeat_entry.repeat_type=repeat_entry.yearly s=[] for n in e.get('exceptions',[]): s.append(bptime.BPTime(n)) repeat_entry.suppressed=s ce.repeat=repeat_entry r[ce.id]=ce return r def _convert_daily_events(self, e, d): """ Conver a daily event from v3 to v2 """ rp=e.repeat if rp.interval==1: d['repeat']='daily' elif rp.interval==0: d['repeat']='monfri' else: d['repeat']='daily' t0=datetime.date(*e.start[:3]) t1=datetime.date(*e.end[:3]) delta_t=datetime.timedelta(1) while t0<=t1: if not e.is_active(t0.year, t0.month, t0.day): d['exceptions'].append((t0.year, t0.month, t0.day)) t0+=delta_t def _convert_weekly_events(self, e, d, idx): """ Convert a weekly event from v3 to v2 """ rp=e.repeat dow=rp.dow t0=datetime.date(*e.start[:3]) t1=t3=datetime.date(*e.end[:3]) delta_t=datetime.timedelta(1) delta_t7=datetime.timedelta(7) if (t1-t0).days>6: t1=t0+datetime.timedelta(6) d['repeat']='weekly' res={} while t0<=t1: dow_0=t0.isoweekday()%7 if (1<<dow_0)&dow: dd=copy.deepcopy(d) dd['start']=(t0.year, t0.month, t0.day, e.start[3], e.start[4]) dd['daybitmap']=self.getdaybitmap(dd['start'], dd['repeat']) t2=t0 while t2<=t3: if not e.is_active(t2.year, t2.month, t2.day): dd['exceptions'].append((t2.year, t2.month, t2.day)) t2+=delta_t7 dd['pos']=idx res[idx]=dd idx+=1 t0+=delta_t return idx, res def _convert3to2(self, dict, ringtone_index): """Convert calendar dict from version 3 to 2.""" r={} idx=0 for k,e in dict.items(): d={} d['start']=e.start d['end']=e.end d['description']=e.description d['alarm']=e.alarm d['changeserial']=1 d['snoozedelay']=0 d['ringtone']=0 try: d['ringtone']=[i for i,r in ringtone_index.items() \ if r.get('name', '')==e.ringtone][0] except: pass rp=e.repeat if rp is None: d['repeat']=None d['exceptions']=[] d['daybitmap']=0 else: s=[] for n in rp.suppressed: s.append(n.get()[:3]) d['exceptions']=s if rp.repeat_type==rp.daily: self._convert_daily_events(e, d) elif rp.repeat_type==rp.weekly: idx, rr=self._convert_weekly_events(e, d, idx) r.update(rr) continue elif rp.repeat_type==rp.monthly: d['repeat']='monthly' elif rp.repeat_type==rp.yearly: d['repeat']='yearly' d['daybitmap']=self.getdaybitmap(d['start'], d['repeat']) d['pos']=idx r[idx]=d idx+=1 if __debug__: print 'Calendar._convert3to2: V2 dict:' print r return r """A class encapsulating the GUI and data of the calendar (all days). A seperate dialog is used to edit the content of one particular day.""" class CalendarPrintDialog (wx.Dialog) : _regular_template='cal_regular.xy' _regular_style='cal_regular_style.xy' _monthly_template='cal_monthly.xy' _monthly_style='cal_monthly_style.xy' def __init__(self, calwidget, mainwindow, config): super(CalendarPrintDialog, self).__init__(mainwindow, -1, 'Print Calendar') self._cal_widget=calwidget self._xcp=self._html=self._dns=None self._dt_index=self._dt_start=self._dt_end=None self._date_changed=self._style_changed=False self._tmp_file=common.gettempfilename("htm") vbs=wx.BoxSizer(wx.VERTICAL) hbs=wx.BoxSizer(wx.HORIZONTAL) sbs=wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Print Range'), wx.VERTICAL) gs=wx.FlexGridSizer(-1, 2, 5, 5) gs.AddGrowableCol(1) gs.Add(wx.StaticText(self, -1, 'Start:'), 0, wx.ALL, 0) self._start_date=wx.DatePickerCtrl(self, style=wx.DP_DROPDOWN | wx.DP_SHOWCENTURY) wx.EVT_DATE_CHANGED(self, self._start_date.GetId(), self.OnDateChanged) gs.Add(self._start_date, 0, wx.ALL, 0) gs.Add(wx.StaticText(self, -1, 'End:'), 0, wx.ALL, 0) self._end_date=wx.DatePickerCtrl(self, style=wx.DP_DROPDOWN | wx.DP_SHOWCENTURY) wx.EVT_DATE_CHANGED(self, self._end_date.GetId(), self.OnDateChanged) gs.Add(self._end_date, 0, wx.ALL, 0) sbs.Add(gs, 1, wx.EXPAND|wx.ALL, 5) hbs.Add(sbs, 0, wx.ALL, 5) self._print_style=wx.RadioBox(self, -1, 'Print Style', choices=['List View', 'Month View'], style=wx.RA_SPECIFY_ROWS) wx.EVT_RADIOBOX(self, self._print_style.GetId(), self.OnStyleChanged) hbs.Add(self._print_style, 0, wx.ALL, 5) vbs.Add(hbs, 0, wx.ALL, 5) vbs.Add(wx.StaticLine(self, -1), 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 5) hbs=wx.BoxSizer(wx.HORIZONTAL) for b in (('Print', -1, self.OnPrint), ('Page Setup', -1, self.OnPageSetup), ('Print Preview', -1, self.OnPrintPreview), ('Close', wx.ID_CANCEL, self.OnClose)): btn=wx.Button(self, b[1], b[0]) hbs.Add(btn, 0, wx.ALIGN_CENTER|wx.ALL, 5) if b[2] is not None: wx.EVT_BUTTON(self, btn.GetId(), b[2]) vbs.Add(hbs, 0, wx.ALIGN_CENTRE|wx.EXPAND|wx.ALL, 5) self.SetSizer(vbs) self.SetAutoLayout(True) vbs.Fit(self) _one_day=wx.DateSpan(days=1) _empty_day=['', []] def _one_day_data(self): r=[str(self._dt_index.GetDay())] events=[] if self._dt_start<=self._dt_index<=self._dt_end: entries=self._cal_widget.getentrydata(self._dt_index.GetYear(), self._dt_index.GetMonth()+1, self._dt_index.GetDay()) else: entries=[] self._dt_index+=self._one_day if len(entries): entries.sort(CalendarEntry.cmp_by_time) for e in entries: print_data=e.print_data events.append('%s: %s'%(print_data[0], print_data[3])) r.append(events) return r def _one_week_data(self): dow=self._dt_index.GetWeekDay() if dow: r=[self._empty_day]*dow else: r=[] for d in range(dow, 7): r.append(self._one_day_data()) if self._dt_index.GetDay()==1: break return r def _one_month_data(self): m=self._dt_index.GetMonth() y=self._dt_index.GetYear() r=['%s %d'%(self._dt_index.GetMonthName(m), y)] while self._dt_index.GetMonth()==m: r.append(self._one_week_data()) return r def _get_monthly_data(self): """ generate a dict suitable to print monthly events """ res=[] self._dt_index=wx.DateTimeFromDMY(1, self._dt_start.GetMonth(), self._dt_start.GetYear()) while self._dt_index<=self._dt_end: res.append(self._one_month_data()) return res def _get_list_data(self): """ generate a dict suitable for printing""" self._dt_index=wx.DateTimeFromDMY(self._dt_start.GetDay(), self._dt_start.GetMonth(), self._dt_start.GetYear()) current_month=None res=a_month=month_events=[] while self._dt_index<=self._dt_end: y=self._dt_index.GetYear() m=self._dt_index.GetMonth() d=self._dt_index.GetDay() entries=self._cal_widget.getentrydata(y, m+1, d) self._dt_index+=self._one_day if not len(entries): continue entries.sort(CalendarEntry.cmp_by_time) if m!=current_month: if len(month_events): a_month.append(month_events) res.append(a_month) current_month=m a_month=['%s %d'%(self._dt_index.GetMonthName(m), y)] month_events=[] for i,e in enumerate(entries): if i: date_str=day_str='' else: date_str=str(d) day_str=self._dt_index.GetWeekDayName( self._dt_index.GetWeekDay()-1, wx.DateTime.Name_Abbr) month_events.append([date_str, day_str]+e.print_data) if len(month_events): a_month.append(month_events) res.append(a_month) return res def _gen_print_data(self): if not self._date_changed and \ not self._style_changed and \ self._html is not None: return self._dt_start=self._start_date.GetValue() self._dt_end=self._end_date.GetValue() if not self._dt_start.IsValid() or not self._dt_end.IsValid(): return print_data=( (self._regular_template, self._regular_style, self._get_list_data), (self._monthly_template, self._monthly_style, self._get_monthly_data)) print_style=self._print_style.GetSelection() print_dict=print_data[print_style][2]() if self._xcp is None: self._xcp=xyaptu.xcopier(None) tmpl=file(guihelper.getresourcefile(print_data[print_style][0]), 'rt').read() self._xcp.setupxcopy(tmpl) elif self._style_changed: tmpl=file(guihelper.getresourcefile(print_data[print_style][0]), 'rt').read() self._xcp.setupxcopy(tmpl) if self._dns is None: self._dns={ 'common': __import__('common') } self._dns['guihelper']=__import__('guihelper') self._dns['events']=[] self._dns['events']=print_dict self._dns['date_range']='%s - %s'%\ (self._dt_start.FormatDate(), self._dt_end.FormatDate()) html=self._xcp.xcopywithdns(self._dns.copy()) sd={'styles': {}, '__builtins__': __builtins__ } try: execfile(guihelper.getresourcefile(print_data[print_style][1]), sd, sd) except UnicodeError: common.unicode_execfile(guihelper.getresourcefile(print_data[print_style][1]), sd, sd) try: self._html=bphtml.applyhtmlstyles(html, sd['styles']) except: if __debug__: file('debug.html', 'wt').write(html) raise self._date_changed=self._style_change=False def OnDateChanged(self, _): self._date_changed=True def OnStyleChanged(self, _): self._style_changed=True def OnPrint(self, _): self._gen_print_data() wx.GetApp().htmlprinter.PrintText(self._html) def OnPageSetup(self, _): wx.GetApp().htmlprinter.PageSetup() def OnPrintPreview(self, _): self._gen_print_data() wx.GetApp().htmlprinter.PreviewText(self._html) def OnHelp(self, _): pass def OnClose(self, _): try: os.remove(self._tmp_file) except: pass self.EndModal(wx.ID_CANCEL)
def _save_to_fs(self, data): _dict={ URLDictKey: { 'urls': data } } database.ensurerecordtype(_dict, urlobjectfactory) self._db.savemajordict(URLDictName, _dict)
def _save_to_db(self, memo_dict): db_rr={} for k, e in memo_dict.items(): db_rr[k]=MemoDataObject(e) database.ensurerecordtype(db_rr, memoobjectfactory) self._main_window.database.savemajordict('memo', db_rr)