Exemple #1
0
    def raw(self, data, field):
        assert field == self.boneName, "render() was called with field %s, expected %s" % (
            field, self.boneName)

        val = data.get(field)
        if not val:
            return None

        structure = self.skelStructure[self.boneName]

        try:
            if not isinstance(val, list):
                val = [val]

            val = [(utils.formatString(
                utils.formatString(self.format,
                                   x["dest"],
                                   structure["relskel"],
                                   prefix=["dest"],
                                   language=conf["currentlanguage"]),
                x["rel"],
                structure["using"],
                prefix=["rel"],
                language=conf["currentlanguage"]) or x["key"]) for x in val]
        except:
            #We probably received some garbage
            print(
                "%s: RelationalBoneExtractor.raw cannot build relational format, maybe garbage received?"
                % self.boneName)
            print(val)
            return None

        return val[0] if len(val) == 1 else val
Exemple #2
0
    def onSelectionDataAvailable(self, req):
        """
			We just received the full information for this entry from the server and can start displaying it
		"""
        data = NetworkService.decode(req)
        assert self.selection["dest"]["key"] == data["values"]["key"]

        if self.using:
            res = (utils.formatString(
                utils.formatString(self.format,
                                   data["values"],
                                   data["structure"],
                                   prefix=["dest"],
                                   language=conf["currentlanguage"]),
                self.selection["rel"],
                self.using,
                prefix=["rel"],
                language=conf["currentlanguage"]) or data["values"]["key"])
        else:
            res = (utils.formatString(
                utils.formatString(self.format,
                                   data["values"],
                                   data["structure"],
                                   prefix=["dest"],
                                   language=conf["currentlanguage"]),
                data["values"],
                data["structure"],
                language=conf["currentlanguage"]) or data["values"]["key"])

        self.selectionTxt["value"] = res
Exemple #3
0
    def render(self, data, field):
        assert field == self.boneName, "render() was called with field %s, expected %s" % (
            field, self.boneName)

        val = data.get(field)
        if not field:
            return ""

        structure = self.skelStructure[self.boneName]

        try:
            if not isinstance(val, list):
                val = [val or ""]

            val = ", ".join([
                utils.formatString(self.format,
                                   x,
                                   structure["using"],
                                   language=conf["currentlanguage"])
                for x in val
            ])
        except:
            # We probably received some garbage
            print(
                "%s: RecordBoneExtractor.render cannot build relational format, maybe garbage received?"
                % self.boneName)
            print(val)
            val = ""

        return val
Exemple #4
0
	def buildDescription(self):
		"""
			Creates the visual representation of our entry
		"""
		# Find any bones in the structure having "frontend_default_visible" set.
		hasDescr = False

		for boneName, boneInfo in self.structure:
			if "params" in boneInfo.keys() and isinstance(boneInfo["params"], dict):
				params = boneInfo["params"]
				if "frontend_default_visible" in params and params["frontend_default_visible"]:
					structure = {k: v for k, v in self.structure}
					wdg = viewDelegateSelector.select(self.module, boneName, structure)

					if wdg is not None:
						self.appendChild(wdg(self.module, boneName, structure).render(self.data, boneName))
						hasDescr = True

		# In case there is no bone configured for visualization, use a format-string
		if not hasDescr:
			format = "$(name)" #default fallback

			if self.module in conf["modules"].keys():
				moduleInfo = conf["modules"][self.module]
				if "format" in moduleInfo.keys():
					format = moduleInfo["format"]

			self.appendChild(html5.utils.unescape(
				utils.formatString(format, self.data, self.structure,
				    language=conf["currentlanguage"])))
Exemple #5
0
    def updateLabel(self, data=None):
        if data is None:
            data = self.data

        self.txtLbl.removeAllChildren()
        txt = utils.formatString(self.relationalBone.format,
                                 data["dest"],
                                 self.relationalBone.relskel,
                                 prefix=["dest"],
                                 language=conf["currentlanguage"])

        if self.ie:
            txt = utils.formatString(txt,
                                     self.ie.serializeForDocument(),
                                     self.relationalBone.using,
                                     prefix=["rel"],
                                     language=conf["currentlanguage"])

        html5.utils.textToHtml(self.txtLbl, txt)
Exemple #6
0
    def updateLabel(self, data=None):
        if data is None:
            data = self.data

        self.txtLbl.removeAllChildren()
        txt = utils.formatString(self.parent.format,
                                 data["dest"],
                                 self.parent.relskel,
                                 prefix=["dest"],
                                 language=conf["currentlanguage"])

        if self.ie:
            txt = utils.formatString(txt,
                                     self.ie.doSave(),
                                     self.parent.using,
                                     prefix=["rel"],
                                     language=conf["currentlanguage"])

        html5.utils.textToHtml(self.txtLbl, txt)
Exemple #7
0
	def buildDescription(self):
		"""
			Generates the visual representation of this entry.
		"""
		format = "$(name)"

		if self.module in conf["modules"].keys():
			moduleInfo = conf["modules"][self.module]
			if "format" in moduleInfo.keys():
				format = moduleInfo["format"]

		self.appendChild(
				html5.TextNode(
						html5.utils.unescape(utils.formatString(format, self.data, self.structure,
						                                        language=conf["currentlanguage"]))))
Exemple #8
0
    def render(self, data, field):
        assert field == self.boneName, "render() was called with field %s, expected %s" % (
            field, self.boneName)
        val = data.get(field)

        lbl = html5.Label()

        if val is None:
            lbl.appendChild(conf["empty_value"])
            return lbl

        structure = self.structure[self.boneName]

        try:
            if not isinstance(val, list):
                val = [val]
                count = 1
            else:
                count = len(val)
                if conf["maxMultiBoneEntries"] and count >= conf[
                        "maxMultiBoneEntries"]:
                    val = val[:conf["maxMultiBoneEntries"] - 1]

            res = "\n".join([
                utils.formatString(self.format,
                                   x,
                                   structure["using"],
                                   language=conf["currentlanguage"])
                for x in val
            ])

            if conf["maxMultiBoneEntries"] and count >= conf[
                    "maxMultiBoneEntries"]:
                res += "\n%s" % translate(
                    "and {count} more",
                    count=count - conf["maxMultiBoneEntries"] - 1)

        except:
            # We probably received some garbage
            print(
                "%s: RecordViewBoneDelegate.render cannot build relational format, maybe garbage received?"
                % self.boneName)
            print(val)

            res = ""

        html5.utils.textToHtml(lbl, html5.utils.unescape(res))
        return lbl