self["disabled"] = True @staticmethod def fromSkelStructure(moduleName, boneName, skelStructure, *args, **kwargs): readOnly = "readonly" in skelStructure[boneName].keys( ) and skelStructure[boneName]["readonly"] return ColorEditBone(moduleName, boneName, readOnly) ##read def unserialize(self, data, extendedErrorInformation=None): if self.boneName in data.keys(): self._setValue(data[self.boneName]) ##save def serializeForPost(self): return {self.boneName: str(self._getValue())} ##UNUSED def serializeForDocument(self): return self.serializeForPost() def CheckForColorBone(moduleName, boneName, skelStucture, *args, **kwargs): return skelStucture[boneName]["type"] == "color" #Register this Bone in the global queue editBoneSelector.insert(3, CheckForColorBone, ColorEditBone) viewDelegateSelector.insert(3, CheckForColorBone, ColorViewBoneDelegate)
if self.selectedLang: self.valuesdict[self.selectedLang] = self.input["value"] return {self.boneName: self.valuesdict} else: return {self.boneName: self.input["value"]} def serializeForDocument(self): return self.serializeForPost() def setExtendedErrorInformation(self, errorInfo): pass def onKeyUp(self, event): if not self.changeEvent.queue: return if self._changeTimeout: html5.window.clearTimeout(self._changeTimeout) self._changeTimeout = html5.window.setTimeout(lambda: self.changeEvent.fire(self), 2500) @staticmethod def checkForTextBone(moduleName, boneName, skelStucture, *args, **kwargs): return skelStucture[boneName]["type"] == "text" # Register this Bone in the global queue editBoneSelector.insert(3, TextEditBone.checkForTextBone, TextEditBone) viewDelegateSelector.insert(3, TextEditBone.checkForTextBone, TextViewBoneDelegate) extractorDelegateSelector.insert(3, TextEditBone.checkForTextBone, TextBoneExtractor)
(extension["type"] == "selectmulti" or extension["type"].startswith("selectmulti.")))) def CheckForSelectMultiBone(moduleName, boneName, skelStructure, *args, **kwargs): return (((skelStructure[boneName]["type"] == "select" or skelStructure[boneName]["type"].startswith("select.")) and skelStructure[boneName].get("multiple", False)) or ((skelStructure[boneName]["type"] == "selectmulti" or skelStructure[boneName]["type"].startswith("selectmulti.")))) #Register this Bone in the global queue editBoneSelector.insert(3, CheckForSelectMultiBone, SelectMultiEditBone) viewDelegateSelector.insert(3, CheckForSelectMultiBone, SelectMultiViewBoneDelegate) extendedSearchWidgetSelector.insert( 1, ExtendedSelectMultiSearch.canHandleExtension, ExtendedSelectMultiSearch) extractorDelegateSelector.insert(3, CheckForSelectMultiBone, SelectMultiBoneExtractor) #Class for AccessMultiSelectBone, a special bone to nicely present user access rights for all skeletons. class AccessMultiSelectBone(html5.Div): states = ["view", "edit", "add", "delete"] def __init__(self, moduleName, boneName, readOnly, values, *args, **kwargs): super(AccessMultiSelectBone, self).__init__(*args, **kwargs) self.boneName = boneName self.moduleName = moduleName
if html5.isReturn(event): self.filterChangedEvent.fire() def updateFilter(self, filter): if self.opMode == "equals": filter[self.extension["target"]] = self.input["value"] elif self.opMode == "from": filter[self.extension["target"] + "$gt"] = self.input["value"] elif self.opMode == "to": filter[self.extension["target"] + "$lt"] = self.input["value"] elif self.opMode == "prefix": filter[self.extension["target"] + "$lk"] = self.input["value"] elif self.opMode == "range": filter[self.extension["target"] + "$gt"] = self.input1["value"] filter[self.extension["target"] + "$lt"] = self.input2["value"] return (filter) @staticmethod def canHandleExtension(extension, view, module): return (isinstance(extension, dict) and "type" in extension.keys() and (extension["type"] == "string" or extension["type"].startswith("string."))) # Register this Bone in the global queue editBoneSelector.insert(3, CheckForStringBone, StringEditBone) viewDelegateSelector.insert(3, CheckForStringBone, StringViewBoneDelegate) extendedSearchWidgetSelector.insert(1, ExtendedStringSearch.canHandleExtension, ExtendedStringSearch) extractorDelegateSelector.insert(3, CheckForStringBone, StringBoneExtractor)
readOnly = "readonly" in skelStructure[boneName].keys( ) and skelStructure[boneName]["readonly"] return EmailEditBone(moduleName, boneName, readOnly) def unserialize(self, data): if self.boneName in data.keys(): self.input["value"] = data[self.boneName] if data[ self.boneName] else "" def serializeForPost(self): if not self["value"] or re.match( "^[a-zA-Z0-9._%-+]+@[a-zA-Z0-9._-]+.[a-zA-Z]{2,6}$", self.input["value"]): return ({self.boneName: self.input["value"]}) raise InvalidBoneValueException() def setSpecialType(self): self.input["type"] = "email" def setExtendedErrorInformation(self, errorInfo): pass def CheckForEmailBone(moduleName, boneName, skelStucture, *args, **kwargs): return (skelStucture[boneName]["type"] == "str.email") #Register this Bone in the global queue editBoneSelector.insert(4, CheckForEmailBone, EmailEditBone) viewDelegateSelector.insert(4, CheckForEmailBone, EmailViewBoneDelegate)
self.selectionCb.appendChild(o) self.sinkEvent("onChange") def onChange(self, event): event.stopPropagation() self.filterChangedEvent.fire() def updateFilter(self, filter): val = self.selectionCb["options"].item(self.selectionCb["selectedIndex"]).value if not val: if self.extension["target"] in filter.keys(): del filter[ self.extension["target"] ] else: filter[ self.extension["target"] ] = val return( filter ) @staticmethod def canHandleExtension( extension, view, modul ): return( isinstance( extension, dict) and "type" in extension.keys() and (extension["type"]=="boolean" or extension["type"].startswith("boolean.") ) ) def CheckForBooleanBone(moduleName, boneName, skelStucture, *args, **kwargs): return skelStucture[boneName]["type"] == "bool" #Register this Bone in the global queue editBoneSelector.insert( 3, CheckForBooleanBone, BooleanEditBone) viewDelegateSelector.insert( 3, CheckForBooleanBone, BooleanViewBoneDelegate) extendedSearchWidgetSelector.insert( 1, ExtendedBooleanSearch.canHandleExtension, ExtendedBooleanSearch )
filter[self.extension["target"]] = self.input["value"] elif self.opMode == "from": filter[self.extension["target"] + "$gt"] = self.input["value"] elif self.opMode == "to": filter[self.extension["target"] + "$lt"] = self.input["value"] elif self.opMode == "prefix": filter[self.extension["target"] + "$lk"] = self.input["value"] elif self.opMode == "range": filter[self.extension["target"] + "$gt"] = self.input1["value"] filter[self.extension["target"] + "$lt"] = self.input2["value"] return (filter) @staticmethod def canHandleExtension(extension, view, module): return (isinstance(extension, dict) and "type" in extension.keys() and (extension["type"] == "numeric" or extension["type"].startswith("numeric."))) def CheckForNumericBone(moduleName, boneName, skelStucture, *args, **kwargs): return skelStucture[boneName]["type"] == "numeric" #Register this Bone in the global queue editBoneSelector.insert(3, CheckForNumericBone, NumericEditBone) viewDelegateSelector.insert(3, CheckForNumericBone, NumericViewBoneDelegate) extendedSearchWidgetSelector.insert(1, ExtendedNumericSearch.canHandleExtension, ExtendedNumericSearch) extractorDelegateSelector.insert(3, CheckForNumericBone, NumericBoneExtractor)
self.extendedErrorInformation = errorInfo for k, v in errorInfo.items(): k = k.replace("%s." % self.boneName, "") idx, err = k.split(".") idx = int(idx) print("k: %s, v: %s" % (k, v)) print("idx: %s" % idx) print(len(self.entries)) if idx >= 0 and idx < len(self.entries): self.entries[idx].setError(err) pass @staticmethod def checkFor(moduleName, boneName, skelStructure, *args, **kwargs): return skelStructure[boneName].get("multiple") and ( skelStructure[boneName]["type"] == "record" or skelStructure[boneName]["type"].startswith("record.")) def checkForRecordBone(moduleName, boneName, skelStructure, *args, **kwargs): return skelStructure[boneName]["type"] == "record" or skelStructure[ boneName]["type"].startswith("record.") # Register this Bone in the global queue editBoneSelector.insert(5, RecordMultiBone.checkFor, RecordMultiBone) editBoneSelector.insert(5, RecordSingleBone.checkFor, RecordSingleBone) viewDelegateSelector.insert(5, checkForRecordBone, RecordViewBoneDelegate) extractorDelegateSelector.insert(4, checkForRecordBone, RecordBoneExtractor)
else: table.table.body.insertBefore(srcTr, dstTr) data.remove(entry) data.insert(dst + 1, entry) else: table.table.body.insertBefore(srcTr, dstTr) data.remove(entry) data.insert(dst, entry) class SortIndexViewBoneDelegate(object): def __init__(self, moduleName, boneName, skelStructure, *args, **kwargs): super(SortIndexViewBoneDelegate, self).__init__() self.skelStructure = skelStructure self.boneName = boneName self.moduleName = moduleName def render(self, data, field): return SortIndexControl(self.moduleName, data) @staticmethod def checkFor(moduleName, boneName, skelStucture, *args, **kwargs): return boneName == "sortindex" viewDelegateSelector.insert(5, SortIndexViewBoneDelegate.checkFor, SortIndexViewBoneDelegate)
return skelStructure[boneName]["type"].startswith("relational.") def CheckForRelationalBoneMultiSelection(moduleName, boneName, skelStructure, *args, **kwargs): isMultiple = "multiple" in skelStructure[boneName].keys( ) and skelStructure[boneName]["multiple"] return isMultiple and skelStructure[boneName]["type"].startswith( "relational.") def CheckForRelationalBoneSingleSelection(moduleName, boneName, skelStructure, *args, **kwargs): isMultiple = "multiple" in skelStructure[boneName].keys( ) and skelStructure[boneName]["multiple"] return not isMultiple and skelStructure[boneName]["type"].startswith( "relational.") #Register this Bone in the global queue editBoneSelector.insert(5, CheckForRelationalBoneMultiSelection, RelationalMultiSelectionBone) editBoneSelector.insert(5, CheckForRelationalBoneSingleSelection, RelationalSingleSelectionBone) viewDelegateSelector.insert(5, CheckForRelationalBoneSelection, RelationalViewBoneDelegate) extendedSearchWidgetSelector.insert(1, RelationalSearch.canHandleExtension, RelationalSearch) extractorDelegateSelector.insert(4, CheckForRelationalBoneSelection, RelationalBoneExtractor)
if self.beginDatepicker["value"] and self.toDatepicker["value"]: clearedFilter["orderby"] = self.extension["target"] clearedFilter[ "%s$gt" % self.extension["target"]] = self.beginDatepicker["value"] clearedFilter[ "%s$lt" % self.extension["target"]] = self.toDatepicker["value"] return clearedFilter def onChange(self, event): event.stopPropagation() self.filterChangedEvent.fire( mutualExclusiveGroupTarget=self.mutualExclusiveGroupTarget, mutualExclusiveGroupKey=self.mutualExclusiveGroupKey) @staticmethod def canHandleExtension(extension, view, module): return isinstance(extension, dict) and "type" in extension.keys() and ( extension["type"] == "date" or extension["type"].startswith("date.")) # Register this Bone in the global queue editBoneSelector.insert(3, CheckForDateBone, DateEditBone) viewDelegateSelector.insert(3, CheckForDateBone, DateViewBoneDelegate) extractorDelegateSelector.insert(3, CheckForDateBone, DateBoneExtractor) extendedSearchWidgetSelector.insert(1, DateRangeFilterPlugin.canHandleExtension, DateRangeFilterPlugin)
self.updateButtons() def CheckForFileBoneSingleSelection(moduleName, boneName, skelStructure, *args, **kwargs): isMultiple = "multiple" in skelStructure[boneName].keys( ) and skelStructure[boneName]["multiple"] return CheckForFileBone(moduleName, boneName, skelStructure) and not isMultiple def CheckForFileBoneMultiSelection(moduleName, boneName, skelStructure, *args, **kwargs): isMultiple = "multiple" in skelStructure[boneName].keys( ) and skelStructure[boneName]["multiple"] return CheckForFileBone(moduleName, boneName, skelStructure) and isMultiple def CheckForFileBone(moduleName, boneName, skelStucture, *args, **kwargs): #print("CHECKING FILE BONE", skelStucture[boneName]["type"]) return (skelStucture[boneName]["type"].startswith("treeitem.file")) #Register this Bone in the global queue editBoneSelector.insert(5, CheckForFileBoneSingleSelection, FileSingleSelectionBone) editBoneSelector.insert(5, CheckForFileBoneMultiSelection, FileMultiSelectionBone) viewDelegateSelector.insert(3, CheckForFileBone, FileViewBoneDelegate) extractorDelegateSelector.insert(3, CheckForFileBone, FileBoneExtractor)
def updateFilter(self, filter): val = self.selectionCb["options"].item(self.selectionCb["selectedIndex"]).value if not val: if self.extension["target"] in filter.keys(): del filter[ self.extension["target"] ] else: filter[ self.extension["target"] ] = val return( filter ) @staticmethod def canHandleExtension( extension, view, module ): return (isinstance(extension, dict) and "type" in extension.keys() and ( ((extension["type"] == "select" or extension["type"].startswith("select.")) and not extension.get("multiple", False)) or (extension["type"] == "selectone" or extension["type"].startswith("selectone.")))) def CheckForSelectOneBone(moduleName, boneName, skelStructure, *args, **kwargs): return (((skelStructure[boneName]["type"] == "select" or skelStructure[boneName]["type"].startswith("select.")) and not skelStructure[boneName].get("multiple", False)) or ((skelStructure[boneName]["type"] == "selectone" or skelStructure[boneName]["type"].startswith("selectone.")))) #Register this Bone in the global queue editBoneSelector.insert( 3, CheckForSelectOneBone, SelectOneEditBone) viewDelegateSelector.insert( 3, CheckForSelectOneBone, SelectOneViewBoneDelegate) extendedSearchWidgetSelector.insert( 1, ExtendedSelectOneSearch.canHandleExtension, ExtendedSelectOneSearch ) extractorDelegateSelector.insert(3, CheckForSelectOneBone, SelectOneBoneExtractor)
def CheckForHierarchyBoneSingleSelection(moduleName, boneName, skelStructure, *args, **kwargs): isMultiple = "multiple" in skelStructure[boneName].keys( ) and skelStructure[boneName]["multiple"] return CheckForHierarchyBone(moduleName, boneName, skelStructure) and not isMultiple def CheckForHierarchyBoneMultiSelection(moduleName, boneName, skelStructure, *args, **kwargs): isMultiple = "multiple" in skelStructure[boneName].keys( ) and skelStructure[boneName]["multiple"] return CheckForHierarchyBone(moduleName, boneName, skelStructure) and isMultiple def CheckForHierarchyBone(moduleName, boneName, skelStucture, *args, **kwargs): return skelStucture[boneName]["type"].startswith("hierarchy.") #Register this Bone in the global queue editBoneSelector.insert(5, CheckForHierarchyBoneSingleSelection, HierarchySingleSelectionBone) editBoneSelector.insert(5, CheckForHierarchyBoneMultiSelection, HierarchyMultiSelectionBone) viewDelegateSelector.insert(3, CheckForHierarchyBone, RelationalViewBoneDelegate) extractorDelegateSelector.insert(3, CheckForHierarchyBone, RelationalBoneExtractor)
self.readOnly = readOnly self.setParams() @staticmethod def fromSkelStructure(moduleName, boneName, skelStructure, *args, **kwargs): return BaseEditBone(moduleName, boneName, skelStructure[boneName].get("readonly", False)) def setParams(self): if self.readOnly: self["disabled"] = True def unserialize(self, data, extendedErrorInformation = None): if self.boneName in data.keys(): self["value"] = data.get(self.boneName, "") def serializeForPost(self): return { self.boneName: self["value"] } def serializeForDocument(self): return self.serializeForPost() def setExtendedErrorInformation(self, errorInfo): pass # Register this Bone in the global queue as generic fallback. editBoneSelector.insert(0, lambda *args, **kwargs: True, BaseEditBone) viewDelegateSelector.insert(0, lambda *args, **kwargs: True, BaseViewBoneDelegate) extractorDelegateSelector.insert(0, lambda *args, **kwargs: True, BaseBoneExtractor)