and extension.get("multiple", False)) or
(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)
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)
self.previewImg["style"]["display"] = "none"
self.updateButtons()
def CheckForTreeDirBoneSingleSelection(moduleName, boneName, skelStructure,
*args, **kwargs):
isMultiple = "multiple" in skelStructure[boneName].keys(
) and skelStructure[boneName]["multiple"]
return CheckForTreeDirBone(moduleName, boneName,
skelStructure) and not isMultiple
def CheckForTreeDirBoneMultiSelection(moduleName, boneName, skelStructure,
*args, **kwargs):
isMultiple = "multiple" in skelStructure[boneName].keys(
) and skelStructure[boneName]["multiple"]
return CheckForTreeDirBone(moduleName, boneName,
skelStructure) and isMultiple
def CheckForTreeDirBone(moduleName, boneName, skelStucture, *args, **kwargs):
return skelStucture[boneName]["type"].startswith("treedir.")
#Register this Bone in the global queue
editBoneSelector.insert(5, CheckForTreeDirBoneSingleSelection,
TreeDirSingleSelectionBone)
editBoneSelector.insert(5, CheckForTreeDirBoneMultiSelection,
TreeDirMultiSelectionBone)
and skelStructure[boneName]["params"]):
verify = skelStructure[boneName]["params"].get("verify", True)
readOnly = skelStructure[boneName].get("readonly", False)
return PasswordEditBone(moduleName, boneName, readOnly, verify)
def unserialize(self, data):
pass
def serializeForPost(self):
if not self.secondinput or self.primeinput[
"value"] == self.secondinput["value"]:
return {self.boneName: self.primeinput["value"]}
raise InvalidBoneValueException()
def serializeForDocument(self):
return {self.boneName: self.primeinput["value"]}
def setExtendedErrorInformation(self, errorInfo):
pass
def CheckForPasswordBone(moduleName, boneName, skelStucture, *args, **kwargs):
return str(skelStucture[boneName]["type"]).startswith("password")
#Register this Bone in the global queue
editBoneSelector.insert(5, CheckForPasswordBone, PasswordEditBone)
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)
return
try:
self.latitude["value"], self.longitude["value"] = data[
self.boneName]
except KeyError:
pass
except TypeError:
pass
def serializeForPost(self):
return {
"{0}.lat".format(self.boneName): self.latitude["value"],
"{0}.lng".format(self.boneName): self.longitude["value"]
}
def serializeForDocument(self):
return self.serializeForPost()
def setExtendedErrorInformation(self, errorInfo):
pass
def CheckForSpatialBone(moduleName, boneName, skelStucture, *args, **kwargs):
return skelStucture[boneName]["type"] == "spatial" or skelStucture[
boneName]["type"].startswith("spatial.")
# Register this Bone in the global queue
editBoneSelector.insert(5, CheckForSpatialBone, SpatialBone)
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["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)
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.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)
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)
