async def history(context, request):
bhr = await get_behavior(context, ICMSBehavior)
container = get_current_container()
result = []
context_url = getMultiAdapter((context, request), IAbsoluteURL)()
container_url = getMultiAdapter((container, request), IAbsoluteURL)()
for ident, hist_data in enumerate(bhr.history):
actor = hist_data.get("actor", "")
type_ = hist_data.get("type", "")
title = hist_data.get("title", "")
value = {
"@id": f"{context_url}/@history/{ident}",
"action": title,
"comments": hist_data.get("comments", ""),
"time": hist_data.get("time", ""),
"transition_title": title,
"type": type_,
"actor": {
"@id": f"{container_url}/@users/{actor}",
"fullname": actor,
"id": actor,
"username": actor
}
}
data = hist_data.get("data", {})
if type_ == 'versioning':
value['may_revert']: False
value['version']: ident
elif type_ == "workflow":
value['state_title'] = data.get('review_state')
value['review_state'] = data.get('review_state')
result.append(value)
return result
async def __call__(self):
result = {'type': self.field_type}
for schema in implementedBy(self.field.__class__).flattened():
self.field_attributes.update(getFields(schema))
for attribute_name in sorted(self.field_attributes.keys()):
attribute_field = self.field_attributes[attribute_name]
if attribute_name in self.filtered_attributes:
continue
element_name = attribute_field.__name__
attribute_field = attribute_field.bind(self.field)
force = (element_name in self.forced_fields)
value = attribute_field.get(self.field)
# For 'default', 'missing_value' etc, we want to validate against
# the imported field type itself, not the field type of the
# attribute
if element_name in self.field_type_attributes or \
element_name in self.non_validated_field_type_attributes:
attribute_field = self.field
text = None
if isinstance(value, bytes):
text = value.decode('utf-8')
elif isinstance(value, str):
text = value
elif IField.providedBy(value):
serializer = getMultiAdapter((value, self.field, self.request),
ISchemaFieldSerializeToJson)
text = await serializer()
elif value is not None and (force
or value != self.field.missing_value):
text = IValueToJson(value)
# handle i18n
# if isinstance(value, Message):
# child.set(ns('domain', I18N_NAMESPACE), value.domain)
# if not value.default:
# child.set(ns('translate', I18N_NAMESPACE), '')
# else:
# child.set(ns('translate', I18N_NAMESPACE), child.text)
# child.text = converter.toUnicode(value.default)
if text:
if attribute_name == 'value_type':
attribute_name = 'items'
result[attribute_name] = text
if result['type'] == 'object':
if IJSONField.providedBy(self.field):
result['properties'] = self.field.json_schema
else:
schema_serializer = getMultiAdapter(
(self.field.schema, self.request), ISchemaSerializeToJson)
result['properties'] = await schema_serializer()
return result
async def __call__(self):
if self.key is _marker:
# No option to write the root of registry
return ErrorResponse('InvalidRequest', 'Needs the registry key')
await lock_object(self.request.container_settings)
data = await self.request.json()
if 'value' in data:
value = data['value']
else:
value = data
assert '.' in self.key, 'Registry key must be dotted.iface.name.fieldname' # noqa
iface, name = self.key.rsplit('.', 1)
iface = resolve_dotted_name(iface)
field = iface[name]
try:
new_value = getMultiAdapter((value, field), IJSONToValue)
except ComponentLookupError:
return ErrorResponse('DeserializationError',
'Cannot deserialize type {}'.format(
str(self.field)),
status=501)
try:
self.request.container_settings[self.key] = new_value
except DeserializationError as e:
return ErrorResponse('DeserializationError',
str(e),
exc=e,
status=400)
return Response(response={}, status=204)
def test_all(dummy_request):
mapping = [
(schema.Object(schema=IResource),
serialize_schema_field.DefaultSchemaFieldSerializer),
(schema.Text(),
serialize_schema_field.DefaultTextSchemaFieldSerializer),
(schema.TextLine(),
serialize_schema_field.DefaultTextLineSchemaFieldSerializer),
(schema.Float(),
serialize_schema_field.DefaultFloatSchemaFieldSerializer),
(schema.Int(), serialize_schema_field.DefaultIntSchemaFieldSerializer),
(schema.Bool(),
serialize_schema_field.DefaultBoolSchemaFieldSerializer),
(schema.List(),
serialize_schema_field.DefaultCollectionSchemaFieldSerializer),
(schema.Choice(values=('one', 'two')),
serialize_schema_field.DefaultChoiceSchemaFieldSerializer),
(schema.Object(schema=IResource),
serialize_schema_field.DefaultObjectSchemaFieldSerializer),
(RichText(),
serialize_schema_field.DefaultRichTextSchemaFieldSerializer),
(schema.Date(),
serialize_schema_field.DefaultDateSchemaFieldSerializer),
(schema.Time(),
serialize_schema_field.DefaultTimeSchemaFieldSerializer),
(schema.Dict(),
serialize_schema_field.DefaultDictSchemaFieldSerializer),
(schema.Datetime(),
serialize_schema_field.DefaultDateTimeSchemaFieldSerializer),
]
container = Container()
for field, klass in mapping:
adapter = getMultiAdapter((field, container, dummy_request),
interface=ISchemaFieldSerializeToJson)
assert isinstance(adapter, klass)
async def render_docs_index(context, request):
if app_settings['swagger'].get('index_html'):
index_file = app_settings['swagger']['index_html']
else:
index_file = os.path.join(here, "index.html")
with open(index_file) as fi:
html = fi.read()
template = Template(html)
swagger_settings = app_settings["swagger"]
url = swagger_settings["base_url"] or request.headers.get(
"X-VirtualHost-Monster")
if url is None:
try:
url = getMultiAdapter((context, request), IAbsoluteURL)()
except ComponentLookupError:
url = "{}://{}".format(get_scheme(request), request.host)
swagger_settings["initial_swagger_url"] = url
return template.render(
app_settings=app_settings,
request=request,
swagger_settings=swagger_settings,
base_url=url,
static_url="{}/swagger_static/".format(url if url != "/" else ""),
)
async def __call__(self):
serializer = getMultiAdapter(
(self.value, self.request), IFactorySerializeToJson
)
result = await serializer()
return result
async def __call__(self):
if not hasattr(self, 'value'):
self.value = [x[1] for x in getUtilitiesFor(IResourceFactory)]
if isinstance(self.value, list):
result = []
for x in self.value:
serializer = getMultiAdapter((x, self.request),
IFactorySerializeToJson)
result.append(await serializer())
else:
serializer = getMultiAdapter((self.value, self.request),
IFactorySerializeToJson)
result = await serializer()
return result
async def add_comment(context, request):
payload = await request.json()
bhr = ICMSBehavior(context)
if not bhr.allow_discussion:
raise HTTPUnauthorized(content={"text": "Not available option"})
await bhr.load()
if bhr.comments is None:
bhr.comments = {}
user_id = get_authenticated_user_id()
comment_uuid = uuid.uuid4().hex
bhr.comments[comment_uuid] = {
"@parent": None,
"author_name": None,
"author_username": user_id,
"creation_date": datetime.now().isoformat(),
"in_reply_to": None,
"is_deletable": True,
"is_editable": True,
"modification_date": datetime.now().isoformat(),
"text": {
"data": payload.get("text", ""),
"mime-type": "text/plain"
},
"user_notification": None,
}
bhr.register()
url = getMultiAdapter((context, request), IAbsoluteURL)()
headers = {"Location": url + "/@comments/" + comment_uuid}
return Response(status=204, headers=headers)
async def render_docs_index(context, request):
if app_settings['swagger'].get('index_html'):
index_file = app_settings['swagger']['index_html']
else:
index_file = os.path.join(here, "index.html")
with open(index_file) as fi:
html = fi.read()
swagger_settings = app_settings["swagger"]
url = swagger_settings["base_url"] or request.headers.get(
"X-VirtualHost-Monster")
if url is None:
try:
url = getMultiAdapter((context, request), IAbsoluteURL)()
except ComponentLookupError:
url = "{}://{}".format(get_request_scheme(request), request.host)
swagger_settings["initial_swagger_url"] = url
if swagger_settings['authentication_allowed']:
auth = AUTH_HTML
else:
auth = ''
return html.format(
app_settings=app_settings,
request=request,
swagger_settings=json.dumps(swagger_settings),
base_url=url,
static_url="{}/swagger_static/".format(url if url != "/" else ""),
auth=auth,
title=swagger_settings['base_configuration']['info']['title'])
async def modify_comment(context, request):
payload = await request.json()
comment_id = request.matchdict["comment_id"]
bhr = ICMSBehavior(context)
if not bhr.allow_discussion:
raise HTTPUnauthorized(content={"text": "Not available option"})
await bhr.load()
if comment_id not in bhr.comments:
raise ErrorResponse("InvalidComment",
"This comment does not exist",
status=412)
user_id = get_authenticated_user_id()
comment = bhr.comments[comment_id]
# TODO: We need ?
if user_id != comment["author_username"]:
raise HTTPUnauthorized(content={"text": "Not the author"})
comment["text"]["data"] = payload.get("text", "")
comment["modification_date"] = datetime.now().isoformat()
bhr.register()
url = getMultiAdapter((context, request), IAbsoluteURL)()
headers = {"Location": url + "/@comments/" + comment_id}
return Response(status=204, headers=headers)
async def test_serialize_resource_omit_behavior(dummy_request):
content = create_content()
serializer = getMultiAdapter((content, dummy_request),
IResourceSerializeToJson)
result = await serializer(
omit=['guillotina.behaviors.dublincore.IDublinCore'])
assert 'guillotina.behaviors.dublincore.IDublinCore' not in result
async def __call__(self, json_value):
if self.request.resource:
fti = queryUtility(
IFactory, name=self.request.resource.type_name)
schema_summary = getMultiAdapter(
(fti, self.request), IResourceSerializeToJson)
json_value['schema'] = await schema_summary()
return json_value
def __init__(self, manager, request=None, loop=None):
self._txn_time = None
self._tid = None
self.status = Status.ACTIVE
# Transaction Manager
self._manager = manager
# List of objects added
# needs to be ordered because content inserted after other might
# reference each other
self.added = OrderedDict()
self.modified = {}
self.deleted = {}
# OIDS to invalidate
self._objects_to_invalidate = []
# List of (hook, args, kws) tuples added by addBeforeCommitHook().
self._before_commit = []
# List of (hook, args, kws) tuples added by addAfterCommitHook().
self._after_commit = []
logger.debug("new transaction")
# Connection to DB
self._db_conn = None
# Transaction on DB
self._db_txn = None
# Lock on the transaction
# some databases need to lock during queries
# this provides a lock for each transaction
# which would correspond with one connection
self._lock = asyncio.Lock(loop=loop)
# we *not* follow naming standards of using "_request" here so
# get_current_request can magically find us here...
self.request = request
self._strategy = getMultiAdapter(
(manager._storage, self),
ITransactionStrategy,
name=manager._storage._transaction_strategy)
self._cache = getMultiAdapter((manager._storage, self),
IStorageCache,
name=manager._storage._cache_strategy)
async def __call__(self):
if (self.behavior is not None and
IAsyncBehavior.implementedBy(self.behavior.__class__)):
# providedBy not working here?
await self.behavior.load(create=True)
# We need to get the upload as async IO and look for an adapter
# for the field to save there by chunks
adapter = getMultiAdapter(
(self.context, self.request, self.field), IFileManager)
return await adapter.upload()
async def test_serialize_omit_main_interface_field(dummy_request):
from guillotina.test_package import FileContent, CloudFile
obj = create_content(FileContent, type_name='File')
obj.file = CloudFile(filename='foobar.json', size=25, md5='foobar')
serializer = getMultiAdapter((obj, dummy_request),
IResourceSerializeToJson)
result = await serializer(omit=['file'])
assert 'file' not in result
result = await serializer()
assert 'file' in result
async def system(context, request):
url = getMultiAdapter((context, request), IAbsoluteURL)()
return {
"id": f"{url}/@system",
"pil_version": version("pillow"),
"guillotina": version("guillotina"),
"guillotina_volto": version("guillotina_volto"),
"python_version": platform.python_version(),
}
async def __call__(self):
for name, field in getFieldsInOrder(self.schema):
serializer = getMultiAdapter(
(field, self.schema, self.request),
ISchemaFieldSerializeToJson)
self.schema_json['properties'][name] = await serializer()
if field.required:
self.schema_json['required'].append(name)
self.schema_json['invariants'] = self.invariants
return self.schema_json
async def test_serialize_resource_include_field(dummy_request):
from guillotina.test_package import FileContent, CloudFile
obj = create_content(FileContent, type_name='File')
obj.file = CloudFile(filename='foobar.json', size=25, md5='foobar')
serializer = getMultiAdapter((obj, dummy_request),
IResourceSerializeToJson)
result = await serializer(
include=['guillotina.behaviors.dublincore.IDublinCore.creators'])
assert 'creators' in result['guillotina.behaviors.dublincore.IDublinCore']
assert len(result['guillotina.behaviors.dublincore.IDublinCore']) == 1
assert 'file' not in result
def __init__(self, manager=None):
if manager is None:
manager = MockTransactionManager()
self._manager = manager
self._tid = 1
self.modified = {}
self.request = None
self._strategy = getMultiAdapter(
(manager._storage, self), ITransactionStrategy,
name=manager._storage._transaction_strategy)
self._cache = DummyCache(manager._storage, self)
async def controlpanel(context, request):
url = getMultiAdapter((context, request), IAbsoluteURL)()
result = []
for item, value in app_settings.get("controlpanels", {}):
result.append({
"@id": f"{url}/@controlpanels/{item}",
"group": value["group"],
"title": value["title"],
})
return result
async def __call__(self, context, request):
if IContentBehavior.implementedBy(context.__class__):
field = self.field.bind(context)
context = context.context
else:
field = self.field.bind(context)
file_manager = getMultiAdapter((context, request, field), IFileManager)
val = await file_manager.save_file(
self.generator,
content_type=self.value['content_type'],
size=len(self.value['data']))
return val
async def __call__(self):
serializer = getMultiAdapter((self.context, self.request),
IResourceSerializeToJson)
include = omit = []
if self.request.GET.get('include'):
include = self.request.GET.get('include').split(',')
if self.request.GET.get('omit'):
omit = self.request.GET.get('omit').split(',')
try:
result = await serializer(include=include, omit=omit)
except TypeError:
result = await serializer()
await notify(ObjectVisitedEvent(self.context))
return result
async def default_get(context, request):
"""We show the available schemas."""
result = {}
factory = get_cached_factory(context.type_name)
result['static'] = []
for schema in factory.behaviors or ():
result['static'].append(schema.__identifier__)
# convert to list, could be frozenset
result['dynamic'] = [b for b in context.__behaviors__]
result['available'] = []
for iface, utility in getUtilitiesFor(IBehavior):
serialize = False
if isinstance(iface, str):
name = iface
else:
name = iface.__identifier__
if name not in result['dynamic'] and name not in result['static']:
adaptable = queryAdapter(context,
utility.interface,
name='',
default=None)
if adaptable:
result['available'].append(name)
serialize = True
schema_serializer = getMultiAdapter(
(utility.interface, request), ISchemaSerializeToJson)
result[name] = await schema_serializer()
else:
serialize = True
if serialize:
schema_serializer = getMultiAdapter((utility.interface, request),
ISchemaSerializeToJson)
result[name] = await schema_serializer()
return result
def schema_compatible(value, schema_or_field):
"""The schema_compatible function converts any value to guillotina.schema
compatible data when possible, raising a TypeError for unsupported values.
This is done by using the ISchemaCompatible converters.
"""
if value is None:
return value
try:
return getMultiAdapter((value, schema_or_field), IJSONToValue)
except ComponentLookupError:
logger.error((u'Deserializer not found for field type '
u'"{0:s}" with value "{1:s}" and it was '
u'deserialized to None.').format(schema_or_field, value))
return None
async def __call__(self):
url = getMultiAdapter((self.context, self.request), IAbsoluteURL)()
result = []
roles = global_roles()
for role in roles:
role_obj = get_utility(IRole, name=role)
result.append(
{
"@id": f"{url}/@roles/{role}",
"@type": "role",
"id": role,
"title": role_obj.title,
}
)
return result
async def __call__(self):
factory = self.factory
result = {
'title': factory.type_name,
'$schema': 'http://json-schema.org/draft-04/schema#',
'type': 'object',
'required': [],
'definitions': {},
'properties': {}
}
# Base object class serialized
for name, field in getFieldsInOrder(factory.schema):
if field.required:
result['required'].append(name)
serializer = getMultiAdapter(
(field, factory.schema, self.request),
ISchemaFieldSerializeToJson)
result['properties'][name] = await serializer()
invariants = []
for i in factory.schema.queryTaggedValue('invariants', []):
invariants.append("%s.%s" % (i.__module__, i.__name__))
result['invariants'] = invariants
# Behavior serialization
for schema in factory.behaviors or ():
schema_serializer = getMultiAdapter(
(schema, self.request), ISchemaSerializeToJson)
serialization = await schema_serializer()
result['properties'][schema_serializer.name] = \
{'$ref': '#/definitions/' + schema_serializer.name},
result['definitions'][schema_serializer.name] = serialization
return result
async def __call__(self, value):
if value is None:
return value
try:
# cloud files are callable adapters...
converter = getMultiAdapter((value, self.field), IJSONToValue)
if callable(converter):
val = await apply_coroutine(converter, self.context,
self.request)
else:
val = converter
self.field.validate(val)
return val
except ComponentLookupError:
logger.error(
(u'Deserializer not found for field type '
u'"{0:s}" with value "{1:s}" and it was '
u'deserialized to None.').format(repr(self.field), value))
return None
async def list_comments(context, request):
bhr = ICMSBehavior(context)
if not bhr.allow_discussion:
raise HTTPUnauthorized(content={"text": "Not available option"})
await bhr.load()
url = getMultiAdapter((context, request), IAbsoluteURL)()
result = []
response = {"@id": url + "/@comments", "items": result}
if bhr.comments is None:
return response
for key, value in bhr.comments.items():
new_comment = deepcopy(value)
new_comment["@type"] = "Discussion Item"
if new_comment.get("@parent", False):
new_comment["@parent"] = url + new_comment.get("@parent")
new_comment["@id"] = url + "/@comments/" + key
new_comment["comment_id"] = key
result.append(new_comment)
return response
async def controlpanel_element(context, request):
url = getMultiAdapter((context, request), IAbsoluteURL)()
type_id = request.matchdict["type_id"]
registry = await get_registry()
result = {
"@id": f"{url}/@controlpanels/{type_id}",
"group": "General",
"title": "Validations Settings",
"data": {},
}
controlpanels = app_settings.get("controlpanels", {})
if type_id in controlpanels:
schema = controlpanels[type_id].get("schema", None)
if schema is None:
return
schemaObj = resolve_dotted_name(schema)
config = registry.for_interface(schemaObj)
schema = {"properties": {}, "fieldsets": [], "required": []}
data = {}
fields = []
for name, field in get_fields_in_order(schemaObj):
if field.required:
result["required"].append(name)
serializer = get_multi_adapter((field, schemaObj, request),
ISchemaFieldSerializeToJson)
schema["properties"][name] = await serializer()
data[name] = config.__getitem__(name)
fields.append(name)
schema["fieldsets"] = [{
"fields": fields,
"id": "default",
"title": "default"
}]
result["schema"] = schema
result["data"] = data
return result
def __init__(self, context, request, field):
iface = import_class(app_settings['cloud_storage'])
alsoProvides(field, iface)
self.real_file_manager = getMultiAdapter((context, request, field),
IFileManager)
