def start():
global ui
ui.show()
api = API()
endtime = datetime.now()
delta = endtime - starttime
api.info('Initialization time: %s' % delta)
def start():
global ui
ui.show()
api = API()
endtime = datetime.now()
delta = endtime - starttime
api.info('Initialization time: %s' % delta)
def main():
qtapp = QApplication(sys.argv)
api = API()
ui = UI(qtapp)
ui.show()
endtime = datetime.now()
delta = endtime - starttime
api.info('Initialization time: %s' % delta)
qtapp.exec_()
def main():
qtapp = QApplication(sys.argv)
api = API()
ui = UI(qtapp)
ui.show()
endtime = datetime.now()
delta = endtime - starttime
api.info('Initialization time: %s' % delta)
qtapp.exec_()
def start():
global ui
if ui.config.options.maximized:
ui.showMaximized()
else:
ui.show()
api = API()
endtime = datetime.now()
delta = endtime - starttime
api.info('Initialization time: %s' % delta)
ui.mainWidget.view.js('$.ajax("/settings")')
def start():
global ui
if ui.config.options.maximized:
ui.showMaximized()
else:
ui.show()
api = API()
endtime = datetime.now()
delta = endtime - starttime
api.info('Initialization time: %s' % delta)
ui.mainWidget.view.js('$.ajax("/settings")')
def main():
qtapp = QApplication(sys.argv)
qtTranslator = QTranslator()
if qtTranslator.load(CWD+"lang/%s.qm" % QLocale.system().name()):
qtapp.installTranslator(qtTranslator)
print QLocale.system().name(), qtapp.tr('Translate loaded')
ui = UI(qtapp)
ui.showMaximized()
api = API()
endtime = datetime.now()
delta = endtime - starttime
api.info('Initialization time: %s' % delta)
print 'Started'
qtapp.exec_()
class Core(QObject): #TODO: Split for CoreUI and Core (without using self.app)
"""
Store all your app logic here
"""
SetProgress = pyqtSignal(int)
def __init__(self):
QObject.__init__(self)
self.app = None
self.collection_desc = None
def _afterInit(self):
"""
when application totally init
"""
self.api = API()
self.api.ex = self.app.getMethod
self.api.config = self.app.config
self.main()
# self.api.info('Core loaded.')
def main(self):
"""
dummy for main core method.
"""
url = 'http://%s:%s/orlangur/_authenticate' % (
self.api.config.options.app.orlangur_server, self.api.config.options.app.orlangur_port)
data = {'username': self.api.config.options.app.orlangur_user,
'password': self.api.config.options.app.orlangur_password}
from urllib.error import URLError
try:
r = req.Request(url, parse.urlencode(data).encode('utf8'))
req.urlopen(r).read()
connection = Connection(self.api.config.options.app.orlangur_server,
self.api.config.options.app.orlangur_port)
db = connection.orlangur
self.db = db
except URLError:
QMessageBox.warning(self.app, 'Error',
'Orlangur server seems down')
return
self.compiler = pystache
self.app.async(self.getConfig, self.assignConfig)
def getConfig(self):
"""
Fetch cloud config
"""
return self.getCollection('en_clients', title='Orlangur')[0]
def assignConfig(self, config):
"""
Callback after getConfig
"""
self.orlangur_config = config
def fillList(self):
"""
Refresh collections list. See fillList_callback as callback
"""
self.app.list.clear()
self.app.statusBar.showMessage('Fetching meta collection...')
self.app.async(lambda: self.getCollection('__meta__'), self.fillList_callback)
def fillList_callback(self, meta):
"""
See fillList
"""
meta = sorted(meta, key=lambda x: x['desc'])
for collection_meta in meta:
item = QListWidgetItem('%s' % collection_meta['desc'])
self.app.list.addItem(item)
item.collection = collection_meta['name']
self.app.statusBar.showMessage('Collection list filled.')
def onClick(self, item):
"""
Collection mouse click handler #Yoda style comment
"""
self.editCollection(item.collection, item.text())
def editCollection(self, collection_name, collection_desc=None, callback=None):
self.collection_name = collection_name
if collection_desc is not None:
self.collection_desc = collection_desc
else:
self.collection_desc = collection_name
if callback is None:
callback = self.editCollection_callback
self.app.async(lambda: self.getCollection(collection_name, meta=True), callback)
self.app.statusBar.showMessage('Fetching collection...')
def editCollection_callback(self, collection):
editor = self.app.addEditorTab(self.collection_desc)
self.app.selectTab(self.collection_desc)
# self.app.viewer.setHtml('')
# self.app.item_list.clear()
try:
meta, collection = collection
except ValueError:
meta = ''
if 'sort_field' in meta:
collection = sorted(collection, key=lambda x: x[meta['sort_field']])
# self.app.rp.setTabText(self.app.rp.tab_list['Editor'], self.collection_desc)
self.app.statusBar.showMessage('Collection fetched successfully')
editor.collection = self.collection_name
content = json.dumps(collection, sort_keys=True, indent=4, ensure_ascii=False)
editor.setText(content)
editor.editor.setModified(False)
editor.editor.setReadOnly(False)
#TODO: make good html view
# if 'item_template' in meta:
# for item in collection:
# self.app.addListItem(self.compiler.render(meta['item_template'], item))
#
# if 'item_template_html' in meta:
# html = '<div id="meta">'
# for item in collection:
# html += self.compiler.render('<div>%s</div>' % meta['item_template_html'], item)
# html += '</div>'
#
# self.app.viewer.setHtml(html)
def getCollection(self, col_name, fetch=True, meta=False, order_by="", **kwargs):
collection = self.db.__getattr__(col_name)
if fetch:
if not order_by:
items = collection.find(criteria=kwargs)
else:
crit = kwargs
crit['$sort'] = {'order_by': 1}
items = collection.find(criteria=crit)
if not meta or col_name == '__meta__':
return items
else:
return [self.getCollection('__meta__', name=col_name)[0], items]
else:
if not meta or col_name == '__meta__':
return collection
else:
return [self.getCollection('__meta__', name=col_name)[0], collection]
def saveCollection(self, name, content, callback=None):
edited = self.app.editors[name].editor.isModified()
edited = True #TODO: fix
if edited:
self.app.pb.setMaximum(len(content))
self.SetProgress.connect(self.app.pb.setValue)
self.app.async(lambda: self._saveCollection(name, content),
lambda: self.saveCollection_callback(name, callback))
else:
self.app.statusBar.showMessage('Collection not modified')
def saveCollection_callback(self, name, callback=None):
self.api.info('Collection %s saved' % name)
self.app.editors[name].setText(json.dumps(self.getCollection(name), sort_keys=True, indent=4, ensure_ascii=False))
if callback is not None:
callback()
def _saveCollection(self, name, content):
collection = self.getCollection(name, fetch=False)
col_content = self.getCollection(name)
items = [i['_id'] for i in col_content]
new_ids = []
for i in content:
if '_id' in i:
new_ids.append(i['_id'])
for i in items:
if i not in new_ids:
collection.remove({'_id': i})
for i, item in enumerate(content):
self.SetProgress.emit(i)
if '_id' in item:
orig = ''
for it in col_content:
if it['_id'] == item['_id']:
orig = it
break
if orig and item != orig:
mods = {'$set': {}, '$unset': {}}
for key in item:
if key != '_id':
mods['$set'][key] = item[key]
for key in orig:
if key not in item:
mods['$unset'][key] = ""
print(mods)
collection.update({'_id': item['_id']}, mods)
else:
collection.insert(item)
def editMeta(self):
self.collection_name = '__meta__'
self.collection_desc = 'Meta'
self.app.async(lambda: self.getCollection('__meta__'), self.editCollection)
def addCollection(self):
name, status = QInputDialog.getText(self.app, 'Add collection', 'Collection name')
if status:
self.app.async(lambda: self._addCollection(name), self.fillList)
def _addCollection(self, name):
collection = self.getCollection('__meta__', fetch=False)
collection.save({
"desc": name,
"name": name,
"template": self.api.config.options.app.default_template})
return True
def delCollection(self):
if self.app.list.currentItem():
name = self.app.list.currentItem().collection
msgBox = QMessageBox()
msgBox.setText("Delete collection")
msgBox.setInformativeText("Do you want to delete %s collection?" % name)
msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msgBox.setDefaultButton(QMessageBox.No)
msgBox.setDetailedText(json.dumps(self.getCollection(name), sort_keys=True, indent=4))
ret = msgBox.exec_()
if ret == QMessageBox.Yes:
# self.app.editor.editor.setReadOnly(True)
self.app.async(lambda: self._delCollection(name), self.fillList)
def _delCollection(self, name):
meta = self.getCollection('__meta__', fetch=False)
meta.remove({'name': name})
return True
def backUp(self):
self.app.pb.setVisible(True)
self.app.async(self._backUp, lambda: self.app.statusBar.showMessage('Backuped successfully'))
def _backUp(self):
backup = {'__meta__': self.getCollection('__meta__')}
self.app.pb.setMaximum(len(backup['__meta__']))
for i, collection in enumerate(backup['__meta__']):
print('Fetching %s' % collection['name'])
backup[collection['name']] = self.getCollection(collection['name'])
self.app.pb.setValue(i)
json.dump(
backup,
open(os.path.join(self.api.CWD, 'backups', str(int(time())) + '.json'), 'w', encoding="utf8"),
indent=4
)
