def addData(self, queryKey: str) -> None: self.isLoading -= 1 if queryKey is not None and queryKey != self.loadingKey: # The Data is for a list we dont display anymore return protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None #cacheTime, skellist, cursor = protoWrap.dataCache[queryKey] skellist = [protoWrap.entryCache[x] for x in protoWrap.queryCache[queryKey]["skelkeys"]] cursor = protoWrap.queryCache[queryKey]["cursor"] # Rebuild our local cache of valid fields if not self.bones: for key, bone in protoWrap.viewStructure.items(): self.bones[key] = bone self._validFields = [x for x in self.fields if x in self.bones] self.fields = [x for x in self.fields if x in self._validFields] if not self.fields: # Select the 10 first bones that do exist to prevent an empty table # Don't show these bones by default in the table systemBones = {"key","creationdate", "changedate", "viurCurrentSeoKeys"} self.fields = [x for x in self.bones if x not in systemBones][:10] self._validFields = self.fields[:] self.rebuildDelegates.emit(protoWrap.viewStructure) self.repaint() self.beginInsertRows(QtCore.QModelIndex(), len(self.dataCache), len(self.dataCache) + len(skellist) - 1) self.dataCache.extend(skellist) self.endInsertRows() if not cursor: self.beginRemoveRows(QtCore.QModelIndex(), len(self.dataCache), len(self.dataCache)) self.completeList = True self.endRemoveRows() self.cursor = cursor self.loadingKey = None if protoWrap.queryCache[queryKey].get("failed"): QtWidgets.QMessageBox.warning(self.parent(), "Failed", "A Network-Request failed")
def __init__(self, parent: QtWidgets.QWidget, module: str, rootNode: Union[str, None] = None, *args: Any, **kwargs: Any): """ CTOR :param parent: Parent widget :param module: Name of the module to show the elements for :param rootNode: Key of the rootNode which data should be displayed. If None, this widget tries to choose one. """ super(HierarchyTreeWidget, self).__init__(parent=parent) self.module = module self.rootNode = rootNode self.loadingKey = None self.overlay = Overlay(self) self.expandList: List[str] = list() self.setHeaderHidden(True) self.setAcceptDrops(True) self.setDragDropMode(self.DragDrop) self.rootNodes = None protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None if not self.rootNode: if protoWrap.rootNodes: self.rootNode = protoWrap.rootNodes[0]["key"] protoWrap.entitiesChanged.connect(self.onHierarchyChanged) protoWrap.childrenAvailable.connect(self.setData) # self.connect( protoWrap, QtCore.SIGNAL("entitiesChanged()"), self.onHierarchyChanged ) # self.connect( self, QtCore.SIGNAL("itemExpanded(QTreeWidgetItem *)"), self.onItemExpanded ) self.itemExpanded.connect(self.onItemExpanded) if self.rootNode: self.loadData() protoWrap.busyStateChanged.connect(self.onBusyStateChanged)
def save(self, data: dict) -> None: protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None if self.module == "_tasks": self.editTaskID = protoWrap.edit(self.key, **data) # request = NetworkService.request("/%s/execute/%s" % ( self.module, self.id ), data, secure=True, # successHandler=self.onSaveResult ) elif self.applicationType == ApplicationType.LIST: # Application: List if self.key and (not self.clone or not data): self.editTaskID = protoWrap.edit(self.key, **data) else: self.editTaskID = protoWrap.add(**data) elif self.applicationType == ApplicationType.HIERARCHY: # Application: Hierarchy if self.key and (not self.clone or not data): self.editTaskID = protoWrap.edit(self.key, **data) else: self.editTaskID = protoWrap.add(self.node, **data) elif self.applicationType == ApplicationType.TREE: # Application: Tree if self.key and not self.clone: self.editTaskID = protoWrap.edit(self.key, self.skelType, **data) else: self.editTaskID = protoWrap.add(self.node, self.skelType, **data) elif self.applicationType == ApplicationType.SINGLETON: # Application: Singleton self.editTaskID = protoWrap.edit(**data) else: raise NotImplementedError() # Should never reach this self.setDisabled(True)
def loadNext(self, forceLoading: bool = False) -> None: if self.isLoading and not forceLoading: return self.isLoading += 1 rawFilter = self.filter.copy() or {} if self.cursor: rawFilter["cursor"] = self.cursor if self.currentSortBone: boneName, descending = self.currentSortBone rawFilter["orderby"] = boneName rawFilter["orderdir"] = "1" if descending else "0" #elif self.dataCache: # FIXME(): Is this still a thing? # invertedOrderDir = False # if "orderdir" in rawFilter and str(rawFilter["orderdir"]) == "1": # invertedOrderDir = True # if "orderby" in rawFilter and rawFilter["orderby"] in self.dataCache[-1]: # if invertedOrderDir: # rawFilter[rawFilter["orderby"] + "$lt"] = self.dataCache[-1][rawFilter["orderby"]] # else: # rawFilter[rawFilter["orderby"] + "$gt"] = self.dataCache[-1][rawFilter["orderby"]] protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None # logger.debug("loadNext.chunk: %r, %r, %r", rawFilter, type(rawFilter), self._chunkSize) rawFilter["limit"] = self._chunkSize self.loadingKey = protoWrap.queryData(**rawFilter)
def htmlDropEvent(self, fileList): if fileList: self.setDisabled(True) fileList = [fileList[0]] # Crop to first file protoWrap = protocolWrapperInstanceSelector.select(self.toModule) uploader = protoWrap.upload(fileList, None) uploader.finished.connect(self.htmlUploadFinished)
def getBreadCrumb(self) -> Tuple[Union[str, None], QtGui.QIcon]: protoWrap = protocolWrapperInstanceSelector.select(self.moduleName) assert protoWrap is not None # FIXME: Bad hack to get the editWidget we belong to skel: Union[Dict[str, Any], None] = None for widget in WidgetHandler.mainWindow.handlerForWidget(self).widgets: if isinstance(widget, EditWidget): if (not widget.key) or widget.clone: # We're adding a new entry if widget.skelType == "leaf": skel = protoWrap.addLeafStructure elif widget.skelType == "node": skel = protoWrap.addNodeStructure else: skel = protoWrap.addStructure else: if widget.skelType == "leaf": skel = protoWrap.editLeafStructure elif widget.skelType == "node": skel = protoWrap.editNodeStructure else: skel = protoWrap.editStructure assert skel is not None assert self.boneName in skel return QtCore.QCoreApplication.translate("ExtendedRelationalBoneSelector", "Select %s") % skel[self.boneName][ "descr"], loadIcon("select")
def onTriggered(self) -> None: reqWrap = protocolWrapperInstanceSelector.select(self.realModule) assert reqWrap is not None node = reqWrap.getNode(self.parent().getNode()) if node: if node["parententry"]: self.parent().setNode(node["parententry"], isInitialCall=True)
def updateVisiblePreview(self) -> None: protoWrap = protocolWrapperInstanceSelector.select(self.toModule) assert protoWrap is not None, "Module %s has no protoWrap" % self.toModule structure = None if self.skelType is None: structure = protoWrap.viewStructure elif self.skelType == "leaf": structure = protoWrap.viewLeafStructure elif self.skelType == "node": structure = protoWrap.viewNodeStructure if structure is None: return if self.selection: logger.debug("selection: %r", self.selection) if self.selection["dest"]["mimetype"].startswith("image/") and not isPyodide: RemoteFile(self.selection["dest"]["dlkey"], successHandler=self.loadIconFromRequest) try: value = self.safeEval.execute(self.ast, { "value": self.selection, "structure": structure, "language": config.conf.adminConfig.get("language", "en") }) except Exception as e: logger.exception(e) value = "(invalid format string)" self.entry.setText(value) else: self.entry.setText("")
def addItem(self, item: Union[Dict[str, Any], str]) -> None: """ Adds an item to the model. The only relevant information is item["key"], the rest is freshly fetched from the server. @param item: The new item @type item: Dict or String """ protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None if not item: return if isinstance(item, dict): if "dest" in item: key = item["dest"]["key"] elif "key" in item: key = item["key"] else: raise NotImplementedError("Unknown item format: %s" % item) if "_type" in item: self.entryFetches.append(protoWrap.queryEntry(key, item["_type"])) else: if self.skelType: self.entryFetches.append(protoWrap.queryEntry(key, self.skelType)) else: self.entryFetches.append(protoWrap.queryEntry(key)) elif isinstance(item, str): if self.skelType is not None: self.entryFetches.append(protoWrap.queryEntry(item, self.skelType)) else: self.entryFetches.append(protoWrap.queryEntry(item)) else: logger.debug("SelectedEntities.addItem: unhandled instance type: %r", item, type(item)) raise NotImplementedError()
def __init__( self, parent: QtWidgets.QWidget, module: str, selection: List[Dict[str, Any]], skelType: str = None, *args: Any, **kwargs: Any): """ :param parent: Our parent widget. :param module: Name of the module which items were going to display. :param selection: Currently selected items. """ super(SelectedEntitiesTableModel, self).__init__(parent, *args, **kwargs) logger.debug("SelectedEntitiesTableModel.init: %r, %r, %r, %r", parent, module, selection, skelType) self.module = self.realModule = module if module.endswith("_rootNode"): self.realModule = module[:-9] self.dataCache: List[Any] = [] self.fields = ["name", "foo"] self.headers: List[Any] = [] self.skelType = skelType self.entryFetches: List[Any] = [] # List of fetch-Tasks we issued protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None structureCache = protoWrap.editStructure # print("model init structure", structureCache) protoWrap.entityAvailable.connect(self.onItemDataAvailable) for item in (selection or []): self.addItem(item)
def rebuildDelegates(self) -> None: """(Re)Attach the view delegates to the table. """ logger.debug("SelectedEntitiesWidget.rebuildDelegates - start:") protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None self.delegates = list() if self.skelType is None: structureCache = protoWrap.viewStructure elif self.skelType == "node": structureCache = protoWrap.viewNodeStructure elif self.skelType == "leaf": structureCache = protoWrap.viewLeafStructure else: structureCache = dict() self.model().headers = [] colum = 0 fields = [x for x in self.model().fields if x in structureCache] for field in fields: self.model().headers.append(structureCache[field]["descr"]) # Locate the best ViewDeleate for this colum delegateFactory = viewDelegateSelector.select(self.realModule, field, structureCache) delegate = delegateFactory(self.realModule, field, structureCache) self.setItemDelegateForColumn(colum, delegate) self.delegates.append(delegate) delegate.request_repaint.connect(self.repaint) colum += 1
def reqDeleteCallback(self, clickedBtn, *args, **kwargs): if clickedBtn == self.requestDeleteBox.button(self.requestDeleteBox.Yes): protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None self.setDisabled(True) protoWrap.delete(self.requestDeleteBox.deleteList) self.requestDeleteBox = None
def commitDataCb(self, editor): protoWrap = protocolWrapperInstanceSelector.select(self.moduleName) assert protoWrap is not None self.editTaskID = protoWrap.edit( self.editingItem["key"], **{self.boneName: editor.serializeForPost()}) self.editingModel = None self.editingIndex = None
def commitDataCb(self, editor): print("IN COMMIT DATA CB") protoWrap = protocolWrapperInstanceSelector.select(self.moduleName) assert protoWrap is not None self.editTaskID = protoWrap.edit(self.editingItem["key"], **{self.boneName: editor.serializeForPost()}) #self.editingModel.dataCache[self.editingIndex.row()][self.boneName] = "-Lade-" self.editingModel = None self.editingIndex = None
def onNodeChanged(self, node: str) -> None: reqWrap = protocolWrapperInstanceSelector.select(self.realModule) assert reqWrap is not None node = reqWrap.getNode(self.parent().getNode()) if not node["parententry"]: self.setEnabled(False) else: self.setEnabled(True)
def dropEvent(self, event: QtGui.QDropEvent) -> None: dataDict = json.loads( event.mimeData().data("viur/treeDragData").data().decode("UTF-8")) protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None destItem = self.itemAt(event.pos()) protoWrap.move(dataDict["nodes"], dataDict["leafs"], destItem.entryData["key"])
def reqDeleteCallback(self, clickedBtn, *args, **kwargs): if clickedBtn == self.requestDeleteBox.button( self.requestDeleteBox.Yes): protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None protoWrap.deleteEntities(self.requestDeleteBox.deleteNode, self.requestDeleteBox.deleteLeafs) self.requestDeleteBox = None return True
def onCustomQueryFinished(self, queryKey: str) -> None: print("onCustomQueryFinished", queryKey) self.clear() if queryKey != self.customQueryKey: return protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None print("pppp1") self.setDisplayData(protoWrap.getNodesForCustomQuery(queryKey))
def loadData(self) -> None: logger.debug("loadData") try: self.itemCache.clear() except: pass self.clear() protoWrap = protocolWrapperInstanceSelector.select(self.realModule) protoWrap.queryData(self.node)
def onTriggered(self) -> None: # self.overlay = Overlay(self) # self.overlay.inform(self.overlay.BUSY) path = self.ui.filenameName.text() logger.debug("path: %r", path) if not path: return protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None protoWrap.queryResultAvailable.connect(self.addData) self.loadNext()
def createEditor(self, parent, option, index): protoWrap = protocolWrapperInstanceSelector.select(self.moduleName) assert protoWrap is not None skelStructure = protoWrap.editStructure wdgGen = editBoneSelector.select(self.moduleName, self.boneName, skelStructure) widget = wdgGen.fromSkelStructure(self.moduleName, self.boneName, skelStructure, editWidget=parent) widget.unserialize(self.editingItem.get(self.boneName), {}) widget.setParent(parent) widget.layout().setSpacing(0) widget.layout().setContentsMargins(0, 0, 0, 0) QtCore.QTimer.singleShot(1, lambda: widget.lineEdit.setFocus()) return widget
def setRepos(self) -> None: """ Called if preloading has finished. Check if there is more than one repository avaiable for us. """ protoWrap = protocolWrapperInstanceSelector.select(self.module) assert protoWrap is not None if len(protoWrap.rootNodes) > 1: for repo in protoWrap.rootNodes: d = FileRepoHandler(self.module, repo) self.addChild(d)
def dropEvent(self, event: QtGui.QDropEvent) -> None: logger.debug("TreeListWidget.dropEvent") dataDict = json.loads( event.mimeData().data("viur/treeDragData").data().decode("UTF-8")) protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None destItem = self.itemAt(event.pos()) if not isinstance(destItem, self.nodeItem): # Entries have no childs, only nodeItems can have children return protoWrap.move(dataDict["nodes"], dataDict["leafs"], destItem.entryData["key"])
def doDownload(self, targetDir: str, files: List[str], dirs: List[str]) -> None: """Download a list of files and/or directories from the server to the local file-system. :param targetDir: Local, existing and absolute path :param files: List of files in this directory which should be downloaded :param dirs: List of directories (in the directory specified by rootNode+path) which should be downloaded """ protoWrap = protocolWrapperInstanceSelector.select(self.getModul()) downloader = protoWrap.download(targetDir, files, dirs) self.parent().layout().addWidget(DownloadStatusWidget(downloader))
def onInputDialogFinished(self, result): if not result: self.inputDialog = None return protpWrap = protocolWrapperInstanceSelector.select(self.parent().module) assert protpWrap is not None data = self.inputDialog.entry.entryData.copy() data["name"] = result key = data["key"] del data["key"] protpWrap.edit(key, "node", **data) self.inputDialog = None
def onItemDataAvailable(self, item: Dict[str, Any]) -> None: """ Fetching the updated information from the server finished. Start displaying that item. """ protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None if item is None or not item["key"] in self.entryFetches: return self.entryFetches.remove(item["key"]) self.layoutAboutToBeChanged.emit() self.dataCache.append(item) self.layoutChanged.emit()
def onTreeChanged(self, node: str) -> None: logger.debug("onTreeChanged: %r", node) if not node: self.loadData() if node != self.node: # Not our part of that tree return if self.customQueryKey is not None: # We currently display a searchresult: return protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None res = protoWrap.childrenForNode(self.node) raise NotImplementedError("check this out again!!!") self.setDisplayData(res)
def doUpload(self, files: List[str], node: str) -> None: """Uploads a list of files to the Server and adds them to the given path on the server. :param files: List of local filenames including their full, absolute path :param node: the rootNode which will receive the uploads """ logger.debug("doUpload: %r, %r", files, node) if not files: return uploadStatusWidget = UploadStatusWidget() self.parent().layout().addWidget(uploadStatusWidget) protoWrap = protocolWrapperInstanceSelector.select(self.getModul()) uploader = protoWrap.upload(files, node) uploadStatusWidget.setUploader(uploader)
def __init__(self, module: str, rootNode: Union[str, None] = None, node: Union[str, None] = None, *args: Any, **kwargs: Any): """ @param module: Name of the module to show the elements for @type module: str @param rootNode: key of the rootNode which data should be displayed. If None, this widget tries to choose one. @type rootNode: str | None @param path: If given, displaying starts in this path @type path: String or None """ super(TreeListView, self).__init__(*args, **kwargs) self.module = self.realModule = module if module.endswith("_rootNode"): self.realModule = module[:-9] self.rootNode = rootNode self.node = node or rootNode self.customQueryKey = None # As loading is performed in background, they might return results for a dataset # which isnt displayed anymore protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None protoWrap.entitiesChanged.connect(self.onTreeChanged) protoWrap.customQueryFinished.connect(self.onCustomQueryFinished) protoWrap.entitiesChanged.connect(self.onTreeChanged) protoWrap.entitiesAppended.connect(self.onAppendedData) self.itemDoubleClicked.connect(self.onItemDoubleClicked) self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) self.customContextMenuRequested.connect( self.onCustomContextMenuRequested) self.setDragEnabled(True) self.setAcceptDrops(True) self.setSortingEnabled(False) self.setIconSize(QtCore.QSize(*[x - 24 for x in self.gridSizeIcon])) self.setGridSize(QtCore.QSize(*self.gridSizeIcon)) self.setSelectionMode(self.ExtendedSelection) if self.rootNode is not None: self.loadData() sizePol = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) self.setSizePolicy(sizePol) self.setResizeMode(QtWidgets.QListWidget.Adjust) self.setViewMode(0) self.setViewMode(1) self.itemCache: Dict[str, Any] = dict()
def rebuild(self) -> None: protoWrap = protocolWrapperInstanceSelector.select(self.realModule) assert protoWrap is not None self.clear() node = self.node revList = [] while node: if node not in protoWrap.dataCache: protoWrap.queryData(node) return node = protoWrap.dataCache[node].copy() revList.append(node) node = node["parententry"] for node in revList[::-1]: aitem = NodeItem(node, self) self.addItem(aitem)