def setPayedSucceeded(self, response):
self.done += 1
if self.done + self.failed == self.total:
conf["mainWindow"].log("success",
translate(self.txtSuccess, count=self.done))
NetworkService.notifyChange(self.parent().parent().module)
def update(self):
user = conf.get("currentUser")
if not user:
NetworkService.request("user",
"view/self",
successHandler=self.onCurrentUserAvailable,
cacheable=False)
return
aitem = html5.Div()
aitem["class"] = ["item", "has-hover", "item--small"]
# userinfo
usrinfo = html5.Div()
usermail = html5.Span()
usermail.appendChild(html5.TextNode(user["name"]))
aitem.appendChild(usermail)
self.popoutlist.appendChild(aitem)
self["title"] = user["name"]
self.currentUser = user["key"] or None
self.addClass("vi-tb-accountmgnt")
try:
self.btn["text"] = "%s. %s" % (user["firstname"][0],
user["lastname"])
except:
self.btn["text"] = user["name"]
def __init__(self,
module,
rootNode=None,
node=None,
context=None,
*args,
**kwargs):
"""
:param module: Name of the module we shall handle. Must be a hierarchy application!
:type module: str
:param rootNode: The repository we shall display. If none, we try to select one.
:type rootNode: str or None
"""
super(TreeWidget, self).__init__()
self.addClass("vi-widget vi-widget--hierarchy is-drop-target")
self.sinkEvent("onKeyDown", "onKeyUp", "onDrop", "onDragOver")
self.module = module
self.rootNode = rootNode
self.node = node or rootNode
self.context = context
# Action bar
self.actionBar = ActionBar(module, "tree")
self.actionBar.setActions(self.getActions(), widget=self)
self.appendChild(self.actionBar)
# Entry frame
self.entryFrame = html5.Ol()
self.entryFrame.addClass("hierarchy")
self.appendChild(self.entryFrame)
# States
self._isCtrlPressed = False
self._expandedNodes = []
self._currentRequests = []
self.path = []
# Selection
self.selectionCallback = None
self.selectionAllow = TreeItemWidget
self.selectionMulti = True
self.selection = []
# Events
self.selectionChangedEvent = EventDispatcher("selectionChanged")
self.selectionActivatedEvent = EventDispatcher("selectionActivated")
self.rootNodeChangedEvent = EventDispatcher("rootNodeChanged")
self.nodeChangedEvent = EventDispatcher("nodeChanged")
# Either load content or get root Nodes
if self.rootNode:
self.reloadData()
else:
NetworkService.request(self.module,
"listRootNodes",
self.context or {},
successHandler=self.onSetDefaultRootNode,
failureHandler=self.showErrorMsg)
def editDir(self, dialog, dirName):
NetworkService.request(self.parent().parent().module,
"edit/node", {
"key": dialog.dirKey,
"name": dirName
},
secure=True,
modifies=True)
def setPageAmount(self):
self.addClass("is-loading")
currentModule = self.parent().parent()
amount = int(self.pages["options"].item(
self.pages["selectedIndex"]).value)
currentModule.setAmount(amount)
NetworkService.notifyChange(currentModule.module)
def fetchSucceeded(self, req):
if self.pendingFetches:
self.fetchNext()
else:
conf["mainWindow"].log("success", "Done :)")
from vi.network import NetworkService # Circular import otherwise
self.removeClass("is-loading")
NetworkService.notifyChange(self.parent().parent().module)
def startPolling(self, *args, **kwargs):
"""
Start querying the server
"""
NetworkService.request("user",
"view/self",
successHandler=self.onUserTestSuccess,
failureHandler=self.onUserTestFail,
cacheable=False)
def nextChunk(self, cursor=None):
if cursor:
self.params["cursor"] = cursor
NetworkService.request(self.module,
"list",
self.params,
successHandler=self.nextChunkComplete,
failureHandler=self.nextChunkFailure)
def doDelete(self, dialog):
deleteList = dialog.deleteList
for x in deleteList:
NetworkService.request(self.parent().parent().module,
"delete", {"key": x},
secure=True,
modifies=True,
successHandler=self.deletedSuccess,
failureHandler=self.deletedFailed)
def rebuildPath(self):
"""
Rebuild the displayed path-list.
"""
self.pathList.removeAllChildren()
NetworkService.request(self.module,
"view/node/%s" % self.node,
successHandler=self.onPathRequestSucceded)
def fetchNext(self):
if not self.pendingFetches:
return
from vi.network import NetworkService # Circular import otherwise
url = self.pendingFetches.pop()
NetworkService.request(None,
url,
secure=True,
successHandler=self.fetchSucceeded,
failureHandler=self.fetchFailed)
def doCloneHierarchy(self, sender=None ):
if self.applicationType == EditWidget.appHierarchy:
NetworkService.request( self.module, "clone",
{ "fromRepo" : self.node, "toRepo" : self.node,
"fromParent" : self.clone_of, "toParent" : self.key },
secure=True, successHandler=self.cloneComplete )
else:
NetworkService.request( conf[ "modules" ][ self.module ][ "rootNodeOf" ], "clone",
{ "fromRepo" : self.clone_of, "toRepo" : self.key },
secure=True, successHandler=self.cloneComplete )
def update(self):
user = conf.get("currentUser")
if not user:
NetworkService.request("user",
"view/self",
successHandler=self.onCurrentUserAvailable,
cacheable=False)
return
if "root" in user["access"]:
self.show()
def onSuccess(self, *args, **kwargs):
"""
Internal callback - The upload succeeded.
"""
if isinstance(self.responseValue["values"], list):
for v in self.responseValue["values"]:
self.uploadSuccess.fire(self, v)
else:
self.uploadSuccess.fire(self, self.responseValue["values"])
NetworkService.notifyChange("file")
self.replaceWithMessage("Upload complete", isSuccess=True)
def doDelete(self, dialog):
deleteList = dialog.deleteList
for x in deleteList:
if isinstance(x, self.parent().parent().nodeWidget):
NetworkService.request(self.parent().parent().module,
"delete/node", {"key": x.data["key"]},
secure=True,
modifies=True)
elif isinstance(x, self.parent().parent().leafWidget):
NetworkService.request(self.parent().parent().module,
"delete/leaf", {"key": x.data["key"]},
secure=True,
modifies=True)
def __init__(self, *args, **kwargs):
super(Tasks, self).__init__(icon="icons-settings", *args, **kwargs)
self.sinkEvent("onClick")
self.hide()
self.addClass("btn vi-tb-tasks")
self.appendChild(html5.TextNode(translate("System")))
if not conf["tasks"]["server"]:
NetworkService.request(None,
"/vi/_tasks/list",
successHandler=self.onTaskListAvailable,
cacheable=False)
self.update()
def doSave(self, closeOnSuccess=False):
self.closeOnSuccess = closeOnSuccess
data = {
"count": self.count._getValue(),
"kind": "2",
"dtstart": self.dtstart
# , "byweekday" : [box["name"] for box in self.byweekday if box["checked"]]
}
# r = rrule.rrule(2, dtstart=datetime(2014, 7,1, 18,00), count=7)
NetworkService.request(self.module,
"addrecurrent/%s" % self.key,
data,
secure=True,
successHandler=self.setData,
failureHandler=self.showErrorMsg)
def reloadData(self):
"""
Removes all currently displayed data and refetches the first batch from the server.
"""
self.table.clear()
self.loadedPages = 0
self.targetPage = 1
self.currentPage = 0
self._currentCursor = None
self._currentRequests = []
filter = {}
if self.context:
filter.update(self.context)
filter.update(self.filter)
filter["limit"] = self._batchSize
self._currentRequests.append(
NetworkService.request(self.module,
"list",
filter,
successHandler=self.onCompletion,
failureHandler=self.showErrorMsg,
cacheable=True))
def onNextBatchNeeded(self):
"""
Requests the next rows from the server and feed them to the table.
"""
if self._currentCursor and not self.isDetaching:
filter = {}
if self.context:
filter.update(self.context)
filter.update(self.filter)
filter["limit"] = self._batchSize
filter["cursor"] = self._currentCursor
self._currentRequests.append(
NetworkService.request(self.module,
"list",
filter,
successHandler=self.onCompletion,
failureHandler=self.showErrorMsg,
cacheable=True))
self._currentCursor = None
else:
self.actionBar.resetLoadingState()
self.entryActionBar.resetLoadingState()
self.tableBottomActionBar.resetLoadingState()
self.table.setDataProvider(None)
def __init__(self, file, node, context=None, *args, **kwargs):
"""
:param file: The file to upload
:type file: A javascript "File" Object
:param node: Key of the desired node of our parents tree application or None for an anonymous upload.
:type node: str or None
"""
super(Uploader, self).__init__()
self.uploadSuccess = EventDispatcher("uploadSuccess")
self.responseValue = None
self.targetKey = None
self.context = context
r = NetworkService.request("file", "getUploadURL",
params={"node": node} if node else {},
successHandler=self.onUploadUrlAvailable,
failureHandler=self.onFailed,
secure=True
)
r.file = file
r.node = node
self.node = node
conf["mainWindow"].log("progress", self)
self.parent().addClass("is-uploading")
def onDrop(self, event):
"""
We got a drop event. Make that item a direct child of our rootNode
"""
if event.target == self.element: # only move if droped
srcKey, skelType = event.dataTransfer.getData("Text").split("/")
NetworkService.request(self.module,
"move", {
"skelType": skelType,
"key": srcKey,
"parentNode": self.rootNode
},
secure=True,
modifies=True)
event.stopPropagation()
def loadNode(self, node, cursor=None, overrideParams=None, reqType=None):
"""
Fetch the (direct) children of the given node.
Once the list is received, append them to their parent node.
:param node: Key of the node to fetch
:type node: str
"""
self.node = node
if reqType is None:
self.loadNode(node, cursor, overrideParams, "node")
if self.leafWidget:
self.loadNode(node, cursor, overrideParams, "leaf")
return
params = {"parententry": node, "orderby": "sortindex", "amount": 99}
if cursor:
params.update({"cursor": cursor})
if overrideParams:
params.update(overrideParams)
if self.context:
params.update(self.context)
r = NetworkService.request(self.module,
"list/" + reqType,
params,
successHandler=self.onRequestSucceded,
failureHandler=self.showErrorMsg)
r.reqType = reqType
r.node = node
self._currentRequests.append(r)
def save(self, data):
self.wasInitialRequest = not len(data) > 0
if self.module == "_tasks":
return #FIXME!
else:
if not data:
NetworkService.request(self.module,
"view/%s" % self.key,
successHandler=self.setData,
failureHandler=self.showErrorMsg)
else:
NetworkService.request(self.module,
"add",
data,
secure=len(data) > 0,
successHandler=self.setData,
failureHandler=self.showErrorMsg)
def onTaskListAvailable(self, req):
data = NetworkService.decode(req)
if not "skellist" in data.keys() or not data["skellist"]:
conf["tasks"]["server"] = []
self.hide()
return
conf["tasks"]["server"] = data["skellist"]
def onSetDefaultRootNode(self, req):
"""
We requested the list of rootNodes for that module and that
request just finished. Parse the respone and set our rootNode
to the first rootNode received.
"""
data = NetworkService.decode(req)
if len(data) > 0:
self.setRootNode(data[0]["key"], self.node)
def closeOrContinue(self, sender=None ):
NetworkService.notifyChange(self.module, key=self.key, action=self.mode)
if self.closeOnSuccess:
if self.module == "_tasks":
self.parent().close()
return
conf["mainWindow"].removeWidget(self)
return
self.clear()
self.bones = {}
if self.mode == "add":
self.key = 0
self.reloadData()
def onClick(self, *args, **kwargs):
if self.mode == "normal" and not self.widgetsDomElm.children():
self.addWidget(self.createWidget())
''' no time right now...
if self.childDomElem is None and "views" in self.moduleInfo:
self.lock()
self._buildViewPanes(self.moduleInfo["views"])
self.unlock()
'''
if self.requestedViews is None and "views.request" in self.moduleInfo:
self.lock()
NetworkService.request(
self.moduleName,
self.moduleInfo["views.request"],
successHandler=self._onRequestViewsAvailable)
super(ListHandler, self).onClick(*args, **kwargs)
def onCompletion(self, req):
"""
Pass the rows received to the datatable.
:param req: The network request that succeed.
"""
if not req in self._currentRequests:
return
self.loadedPages += 1
self.currentPage = self.loadedPages
self._currentRequests.remove(req)
self.actionBar.resetLoadingState()
self.entryActionBar.resetLoadingState()
self.tableBottomActionBar.resetLoadingState()
data = NetworkService.decode(req)
if data["structure"] is None:
if self.table.getRowCount():
# We cant load any more results
self.targetPage = self.loadedPages #reset targetpage to maximum
self.requestingFinishedEvent.fire()
self.table.setDataProvider(None)
self.table.onTableChanged(None, self.table.getRowCount())
else:
self.table["style"]["display"] = "none"
self.emptyNotificationDiv.addClass("is-active")
self.updateEmptyNotification()
return
self.table["style"]["display"] = ""
self.emptyNotificationDiv.removeClass("is-active")
self._structure = data["structure"]
if not self._tableHeaderIsValid:
if not self.columns:
self.columns = []
for boneName, boneInfo in data["structure"]:
if boneInfo["visible"]:
self.columns.append(boneName)
self.setFields(self.columns)
if data["skellist"] and "cursor" in data.keys():
self._currentCursor = data["cursor"]
self.table.setDataProvider(self)
else:
self.requestingFinishedEvent.fire()
self.table.setDataProvider(None)
self.table.extend(data["skellist"], writeToModel=True)
#if targetPage higher than loadedPage, request next Batch
if self.targetPage > self.loadedPages:
self.onNextBatchNeeded()
def createDir(self, dialog, dirName):
if len(dirName) == 0:
return
r = NetworkService.request(self.parent().parent().module,
"add/node", {
"node": self.parent().parent().node,
"name": dirName
},
secure=True,
modifies=True,
successHandler=self.onMkDir)
r.dirName = dirName
def nextChunkComplete(self, req):
answ = NetworkService.decode(req)
if self.structure is None:
self.structure = answ["structure"]
if not answ["skellist"]:
self.exportToFile()
return
self.data.extend(answ["skellist"])
self.nextChunk(answ["cursor"])
