def list_features(graph, entity, ref_entity, context):
from .models import UserComponent, ContentVariant
if not ref_entity:
return
if isinstance(entity, UserComponent):
active_features = entity.features.all()
else:
active_features = ContentVariant.objects.filter(
Q(feature_for_contents=entity) |
Q(feature_for_components=entity.usercomponent)
)
add_property(
graph, "features", ref=ref_entity,
literal=active_features.values_list("name", flat=True),
datatype=XSD.string,
iterate=True
)
for feature in active_features:
if context["scope"] != "export":
for name, url_feature in feature.feature_urls:
ref_feature = URIRef("{}{}".format(
context["hostpart"],
url_feature
))
graph.add((
ref_entity,
spkcgraph["action:feature"],
ref_feature
))
graph.add((
ref_feature,
spkcgraph["feature:name"],
Literal(name, datatype=XSD.string)
))
def map_data(self, name, field, data, graph, context):
if isinstance(data, File):
return get_settings_func(
"SPIDER_FILE_EMBED_FUNC",
"spkcspider.apps.spider.functions.embed_file_default"
)(name, data, self, context)
ret = literalize(data, field, domain_base=context["hostpart"])
if isinstance(ret, dict):
base = ret["ref"]
if ret["type"]:
graph.add((base, RDF["type"], ret["type"]))
# create subproperties
for key, val in ret["items"].items():
value_node = add_property(graph, key, ref=base, literal=val)
graph.add((
value_node,
spkcgraph["hashable"],
Literal(is_hashable(field, key))
))
return base
return ret
def serialize_content(graph, content, context, embed=False):
if VariantType.anchor in content.ctype.ctype:
url_content = "{}{}".format(
get_anchor_domain(),
content.get_absolute_url()
)
else:
url_content = "{}{}".format(
context["hostpart"],
content.get_absolute_url()
)
ref_content = URIRef(url_content)
# is already node in graph
if (ref_content, spkcgraph["type"], None) in graph:
return ref_content
if (
context.get("ac_namespace", None) and
context["sourceref"] != ref_content
):
graph.add((
context["sourceref"],
context["ac_namespace"],
ref_content
))
add_property(
graph, "name", ref=ref_content, ob=content, datatype=XSD.string
)
add_property(
graph, "description", ref=ref_content, ob=content, datatype=XSD.string
)
add_property(
graph, "info", ref=ref_content, ob=content, datatype=XSD.string
)
add_property(
graph, "id", ref=ref_content, literal=content.id,
datatype=XSD.integer
)
add_property(
graph, "priority", ref=ref_content, ob=content
)
if (
VariantType.component_feature in content.ctype.ctype or
VariantType.content_feature in content.ctype.ctype
):
graph.add((
ref_content,
RDF["type"],
spkcgraph["spkc:Feature"]
))
else:
graph.add((
ref_content,
RDF["type"],
spkcgraph["spkc:Content"]
))
# always add type info to content (which content type)
graph.add((
ref_content,
spkcgraph["type"],
Literal(content.ctype.name, datatype=XSD.string)
))
if context["scope"] == "export":
add_property(
graph, "attached_to_content", ref=ref_content, ob=content
)
add_property(
graph, "features", ref=ref_content,
literal=content.features.exclude(
Q(name="DomainMode") | Q(name="DefaultActions")
).values_list("name", flat=True),
datatype=XSD.string, iterate=True
)
if embed:
list_features(graph, content, ref_content, context)
content.content.serialize(graph, ref_content, context)
return ref_content
def serialize_component(graph, component, context, visible=True):
# visible: everything is visible elsewise only public
ref_component = URIRef("{}{}".format(
context["hostpart"], component.get_absolute_url()
))
if component.public:
visible = True
if not visible and ref_component != context["sourceref"]:
return None
graph.set((
ref_component,
spkcgraph["type"],
Literal("Component", datatype=XSD.string)
))
graph.add((
ref_component,
RDF["type"],
spkcgraph["spkc:Component"]
))
if component.primary_anchor:
url_content = "{}{}".format(
context["hostpart"],
component.primary_anchor.get_absolute_url()
)
add_property(
graph, "primary_anchor", ref=ref_component,
literal=url_content, datatype=XSD.anyURI
)
if component.public or context["scope"] == "export":
add_property(
graph, "user", ref=ref_component, literal=component.username
)
add_property(
graph, "name", ref=ref_component, literal=component.__str__()
)
add_property(
graph, "description", ref=ref_component, ob=component
)
if context["scope"] == "export":
add_property(
graph, "required_passes", ref=ref_component, ob=component
)
add_property(
graph, "token_duration", ref=ref_component, ob=component
)
graph.add((
ref_component, spkcgraph["strength"], Literal(component.strength)
))
add_property(
graph, "features", ref=ref_component,
literal=component.features.exclude(
name="DomainMode"
).values_list("name", flat=True),
datatype=XSD.string, iterate=True
)
if (
context.get("uc_namespace", None) and
context["sourceref"] != ref_component
):
graph.add((
context["sourceref"],
context["uc_namespace"],
ref_component
))
return ref_component
def render_to_response(self, context):
if context["scope"] != "export" and "raw" not in self.request.GET:
return super().render_to_response(context)
session_dict = {
"request": self.request,
"context": context,
"scope": context["scope"],
"uc": self.usercomponent,
"hostpart": context["hostpart"],
"sourceref":
URIRef("%s%s" % (context["hostpart"], self.request.path))
}
g = Graph()
g.namespace_manager.bind("spkc", spkcgraph, replace=True)
embed = False
if (context["scope"] == "export"
or self.request.GET.get("raw", "") == "embed"):
embed = True
if context["object_list"]:
p = paginate_stream(
context["object_list"],
getattr(settings, "SPIDER_SERIALIZED_PER_PAGE",
settings.SPIDER_OBJECTS_PER_PAGE),
settings.SPIDER_MAX_EMBED_DEPTH)
else:
# no content, pagination works here only this way
p = paginate_stream(
UserComponent.objects.filter(pk=self.usercomponent.pk), 1, 1)
context["object_list"]
page = 1
try:
page = int(self.request.GET.get("page", "1"))
except Exception:
pass
if hasattr(self.request, "token_expires"):
session_dict["expires"] = self.request.token_expires.strftime(
"%a, %d %b %Y %H:%M:%S %z")
if page <= 1:
# "expires" (string) different from "token_expires" (datetime)
if session_dict.get("expires"):
add_property(g,
"token_expires",
ob=session_dict["request"],
ref=session_dict["sourceref"])
assert not context.get("machine_variants") or self.request.is_owner
for machinec in context.get("machine_variants", []):
g.add((session_dict["sourceref"], spkcgraph["create:name"],
Literal(machinec, datatype=XSD.string)))
g.add((session_dict["sourceref"], spkcgraph["scope"],
Literal(context["scope"], datatype=XSD.string)))
g.add((session_dict["sourceref"], spkcgraph["type"],
Literal("Component", datatype=XSD.string)))
g.add((session_dict["sourceref"], spkcgraph["strength"],
Literal(self.usercomponent.strength, datatype=XSD.integer)))
if context["referrer"]:
g.add((session_dict["sourceref"], spkcgraph["referrer"],
Literal(context["referrer"], datatype=XSD.anyURI)))
token = getattr(session_dict["request"], "auth_token", None)
if token:
token = token.token
g.add((session_dict["sourceref"], spkcgraph["action:view"],
Literal(merge_get_url(str(session_dict["sourceref"]),
token=token),
datatype=XSD.anyURI)))
if context["token_strength"]:
add_property(g,
"token_strength",
ref=session_dict["sourceref"],
literal=context["token_strength"],
datatype=XSD.integer)
add_property(g,
"intentions",
ref=session_dict["sourceref"],
literal=context["intentions"],
datatype=XSD.string,
iterate=True)
serialize_stream(g, p, session_dict, page=page, embed=embed)
ret = HttpResponse(g.serialize(format="turtle"),
content_type="text/turtle;charset=utf-8")
if session_dict.get("expires", None):
ret['X-Token-Expires'] = session_dict["expires"]
# allow cors requests for raw
ret["Access-Control-Allow-Origin"] = "*"
return ret
def render_serialize(self, **kwargs):
from ..models import AssignedContent
# ** creates copy of dict, so it is safe to overwrite kwargs here
session_dict = {
"request": kwargs["request"],
"context": kwargs,
"scope": kwargs["scope"],
"hostpart": kwargs["hostpart"],
"ac_namespace": spkcgraph["contents"],
"sourceref": URIRef(urljoin(
kwargs["hostpart"], kwargs["request"].path
))
}
g = Graph()
g.namespace_manager.bind("spkc", spkcgraph, replace=True)
p = paginate_stream(
AssignedContent.objects.filter(id=self.associated_id),
getattr(
settings, "SPIDER_SERIALIZED_PER_PAGE",
settings.SPIDER_OBJECTS_PER_PAGE
),
settings.SPIDER_MAX_EMBED_DEPTH
)
page = 1
try:
page = int(session_dict["request"].GET.get("page", "1"))
except Exception:
pass
serialize_stream(
g, p, session_dict,
page=page,
embed=True
)
if hasattr(kwargs["request"], "token_expires"):
session_dict["expires"] = kwargs["request"].token_expires.strftime(
"%a, %d %b %Y %H:%M:%S %z"
)
if page <= 1:
source = kwargs.get("source", self)
# "expires" (string) different from "token_expires" (datetime)
if session_dict.get("expires"):
add_property(
g, "token_expires", ob=session_dict["request"],
ref=session_dict["sourceref"]
)
if kwargs.get("machine_variants"):
assert kwargs["request"].is_owner
ucref = URIRef(urljoin(
kwargs["hostpart"],
source.associated.usercomponent.get_absolute_url()
))
for machinec in kwargs["machine_variants"]:
g.add((
ucref,
spkcgraph["create:name"],
Literal(machinec, datatype=XSD.string)
))
g.add((
session_dict["sourceref"],
spkcgraph["scope"],
Literal(kwargs["scope"], datatype=XSD.string)
))
uc = kwargs.get("source", self.associated.usercomponent)
g.add((
session_dict["sourceref"], spkcgraph["strength"],
Literal(uc.strength, datatype=XSD.integer)
))
token = getattr(session_dict["request"], "auth_token", None)
if token:
token = token.token
url2 = merge_get_url(str(session_dict["sourceref"]), token=token)
g.add(
(
session_dict["sourceref"],
spkcgraph["action:view"],
URIRef(url2)
)
)
if kwargs["referrer"]:
g.add((
session_dict["sourceref"],
spkcgraph["referrer"],
Literal(kwargs["referrer"], datatype=XSD.anyURI)
))
if kwargs["token_strength"]:
add_property(
g, "token_strength", ref=session_dict["sourceref"],
literal=kwargs["token_strength"]
)
add_property(
g, "intentions", ref=session_dict["sourceref"],
literal=kwargs["intentions"], datatype=XSD.string,
iterate=True
)
ret = HttpResponse(
g.serialize(format="turtle"),
content_type="text/turtle;charset=utf-8"
)
if session_dict.get("expires", None):
ret['X-Token-Expires'] = session_dict["expires"]
# allow cors requests for raw
ret["Access-Control-Allow-Origin"] = "*"
return ret
def serialize(self, graph, ref_content, context):
# context may not be updated here
form = self.get_form(context["scope"])(
**self.get_form_kwargs(
disable_data=True,
**context
)
)
# context["abilities"] cache available if accessed via access
# cannot update without breaking serializing, embed
if "abilities" in context:
abilities = context["abilities"]
else:
abilities = set(self.get_abilities(context))
for ability in abilities:
assert(ability not in default_abilities)
graph.add((
ref_content,
spkcgraph["ability:name"],
Literal(ability, datatype=XSD.string)
))
for name, field in form.fields.items():
raw_value = form.initial.get(name, None)
try:
value = field.to_python(raw_value)
except Exception as exc:
# user can corrupt tags, so just debug
level = logging.WARNING
if getattr(form, "layout_generating_form", False):
level = logging.DEBUG
logger.log(
level,
"Corrupted field: %s, form: %s, error: %s",
name, form, exc
)
continue
if not isinstance(value, (list, tuple, models.QuerySet)):
value = [value]
value_node = add_property(
graph,
name,
ref=ref_content,
literal=map(
lambda i: self.map_data(name, field, i, graph, context),
value
),
iterate=True
)
graph.add((
value_node,
spkcgraph["hashable"],
Literal(is_hashable(field))
))
graph.add((
value_node,
spkcgraph["fieldname"],
Literal(form.add_prefix(name), datatype=XSD.string)
))