def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ["tiddlyweb.store"]
length = environ["CONTENT_LENGTH"]
usersign = environ["tiddlyweb.usersign"]
try:
bag = store.get(bag)
bag.policy.allows(usersign, "manage")
except NoBagError:
create_policy_check(environ, "bag", usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ["wsgi.input"].read(int(length))
serializer.from_string(content.decode("utf-8"))
bag.policy.owner = usersign["name"]
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError, exc:
raise HTTP400("unable to put bag: %s" % exc)
def delete(environ, start_response):
"""
Remove a bag and its tiddlers from the store.
How the store chooses to handle remove and what
it means is up to the store.
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
usersign = environ["tiddlyweb.usersign"]
bag = _get_bag(environ, bag_name, True)
bag.policy.allows(usersign, "manage")
# reuse the store attribute that was set on the
# bag when we "got" it.
# we don't need to check for existence here because
# the above get already did
try:
store = environ["tiddlyweb.store"]
store.delete(bag)
except StoreMethodNotImplemented:
raise HTTP400("Bag DELETE not supported")
start_response("204 No Content", [])
return []
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError, exc:
raise HTTP400('unable to put bag: %s' % exc)
def delete(environ, start_response):
"""
Handle ``DELETE`` on a single bag URI.
Remove the :py:class:`bag <tiddlyweb.model.bag.Bag>` and the
:py:class:`tiddlers <tiddlyweb.model.tiddler.Tiddler>` within
from the :py:class:`store <tiddlyweb.store.Store>`.
How the store chooses to handle remove and what it means is
up to the store.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
usersign = environ['tiddlyweb.usersign']
bag = _get_bag(environ, bag_name)
bag.policy.allows(usersign, 'manage')
# reuse the store attribute that was set on the
# bag when we "got" it.
# we don't need to check for existence here because
# the above get already did
try:
store = environ['tiddlyweb.store']
store.delete(bag)
except StoreMethodNotImplemented:
raise HTTP400('Bag DELETE not supported')
start_response("204 No Content", [])
return []
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError, exc:
raise HTTP400('unable to put bag: %s' % exc)
def get(environ, start_response):
"""
Get a representation in some serialization of
a bag (the bag itself not the tiddlers within).
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = _get_bag(environ, bag_name, True)
bag.policy.allows(environ['tiddlyweb.usersign'], 'manage')
try:
serialize_type, mime_type = web.get_serialize_type(environ)
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = serializer.to_string()
except NoSerializationError:
raise HTTP415('Content type not supported: %s' % mime_type)
start_response("200 Ok",
[('Content-Type', mime_type),
('Vary', 'Accept')])
return [content]
def delete(environ, start_response):
"""
Remove a bag and its tiddlers from the store.
How the store chooses to handle remove and what
it means is up to the store.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
usersign = environ['tiddlyweb.usersign']
bag = _get_bag(environ, bag_name)
bag.policy.allows(usersign, 'manage')
# reuse the store attribute that was set on the
# bag when we "got" it.
# we don't need to check for existence here because
# the above get already did
try:
store = environ['tiddlyweb.store']
store.delete(bag)
except StoreMethodNotImplemented:
raise HTTP400('Bag DELETE not supported')
start_response("204 No Content", [])
return []
def get(environ, start_response):
"""
Get a representation in some serialization of
a bag (the bag itself not the tiddlers within).
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = _get_bag(environ, bag_name)
bag.policy.allows(environ['tiddlyweb.usersign'], 'manage')
return send_entity(environ, start_response, bag)
def get(environ, start_response):
"""
Get a representation in some serialization of
a bag (the bag itself not the tiddlers within).
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = _get_bag(environ, bag_name)
bag.policy.allows(environ['tiddlyweb.usersign'], 'manage')
return send_entity(environ, start_response, bag)
def get(environ, start_response):
"""
Get a representation in some serialization of
a bag (the bag itself not the tiddlers within).
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = _get_bag(environ, bag_name)
bag.policy.allows(environ["tiddlyweb.usersign"], "manage")
return send_entity(environ, start_response, bag)
def _determine_tiddler(environ, bag_finder):
"""
Determine, using URL info, the target tiddler.
This can be complicated because of the mechanics
of recipes and bags.
"""
tiddler_name = web.get_route_value(environ, 'tiddler_name')
try:
revision = web.get_route_value(environ, 'revision')
revision = web.handle_extension(environ, revision)
except KeyError:
tiddler_name = web.handle_extension(environ, tiddler_name)
revision = None
tiddler = Tiddler(tiddler_name)
if revision:
try:
revision = int(revision)
tiddler.revision = revision
except ValueError, exc:
raise HTTP404('%s not a revision of %s: %s' %
(revision, tiddler_name, exc))
def _base_tiddler_object(environ, tiddler_name, revisions):
"""
Create a tiddler object, without bag or recipe, based on
URI values.
``revisions`` is true when the request is for a revisions
collection. When true, extension handling is not done on
the tiddler_name.
"""
if not revisions:
try:
revision = get_route_value(environ, 'revision')
revision = handle_extension(environ, revision)
except KeyError:
tiddler_name = handle_extension(environ, tiddler_name)
revision = None
else:
revision = None
tiddler = Tiddler(tiddler_name)
tiddler.revision = revision # reset to default None if HEAD
return tiddler
def _base_tiddler_object(environ, tiddler_name, revisions):
"""
Create a tiddler object, without bag or recipe, based on
URI values.
``revisions`` is true when the request is for a revisions
collection. When true, extension handling is not done on
the tiddler_name.
"""
if not revisions:
try:
revision = get_route_value(environ, 'revision')
revision = handle_extension(environ, revision)
except KeyError:
tiddler_name = handle_extension(environ, tiddler_name)
revision = None
else:
revision = None
tiddler = Tiddler(tiddler_name)
tiddler.revision = revision # reset to default None if HEAD
return tiddler
def _determine_tiddler(environ, bag_finder):
"""
Determine, using URL info, the target tiddler.
This can be complicated because of the mechanics
of recipes and bags.
"""
tiddler_name = web.get_route_value(environ, 'tiddler_name')
try:
revision = web.get_route_value(environ, 'revision')
revision = web.handle_extension(environ, revision)
except KeyError:
tiddler_name = web.handle_extension(environ, tiddler_name)
revision = None
tiddler = Tiddler(tiddler_name)
if revision:
try:
revision = int(revision)
tiddler.revision = revision
except ValueError, exc:
raise HTTP404('%s not a revision of %s: %s' %
(revision, tiddler_name, exc))
def _determine_tiddler(environ, bag_finder):
"""
Determine, using URL info, the target tiddler.
This can be complicated because of the mechanics
of recipes and bags.
"""
tiddler_name = environ['wsgiorg.routing_args'][1]['tiddler_name']
tiddler_name = urllib.unquote(tiddler_name)
tiddler_name = unicode(tiddler_name, 'utf-8')
revision = environ['wsgiorg.routing_args'][1].get('revision', None)
if revision:
revision = web.handle_extension(environ, revision)
else:
tiddler_name = web.handle_extension(environ, tiddler_name)
tiddler = Tiddler(tiddler_name)
if revision:
try:
revision = int(revision)
tiddler.revision = revision
except ValueError, exc:
raise HTTP404('%s not a revision of %s: %s' %
(revision, tiddler_name, exc))
def _determine_tiddler(environ, bag_finder):
"""
Determine, using URL info, the target tiddler.
This can be complicated because of the mechanics
of recipes and bags.
"""
tiddler_name = environ['wsgiorg.routing_args'][1]['tiddler_name']
tiddler_name = urllib.unquote(tiddler_name)
tiddler_name = unicode(tiddler_name, 'utf-8')
revision = environ['wsgiorg.routing_args'][1].get('revision', None)
if revision:
revision = web.handle_extension(environ, revision)
else:
tiddler_name = web.handle_extension(environ, tiddler_name)
tiddler = Tiddler(tiddler_name)
if revision:
try:
revision = int(revision)
tiddler.revision = revision
except ValueError, exc:
raise HTTP404('%s not a revision of %s: %s' %
(revision, tiddler_name, exc))
def put(environ, start_response):
"""
Handle ``PUT`` on a single recipe URI.
Put a :py:class:`recipe <tiddlyweb.model.recipe.Recipe>` to the server,
meaning the description, policy and recipe list of the recipe,
if :py:class:`policy <tiddlyweb.model.policy.Policy>` allows.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError as exc:
raise HTTP400('unable to put recipe: %s' % exc)
except TypeError as exc:
raise HTTP400('malformed input: %s' % exc)
except NoSerializationError:
raise HTTP415('Content type %s not supported' % serialize_type)
start_response("204 No Content",
[('Location', web.recipe_url(environ, recipe))])
return []
def put(environ, start_response):
"""
Handle ``PUT`` on a single recipe URI.
Put a :py:class:`recipe <tiddlyweb.model.recipe.Recipe>` to the server,
meaning the description, policy and recipe list of the recipe,
if :py:class:`policy <tiddlyweb.model.policy.Policy>` allows.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError as exc:
raise HTTP400('unable to put recipe: %s' % exc)
except TypeError as exc:
raise HTTP400('malformed input: %s' % exc)
except NoSerializationError:
raise HTTP415('Content type %s not supported' % serialize_type)
start_response("204 No Content",
[('Location', web.recipe_url(environ, recipe))])
return []
def get(environ, start_response):
"""
Handle ``GET`` on a single bag URI.
Get a representation in some serialization determined by
:py:mod:`tiddlyweb.web.negotiate` of a :py:class:`bag
<tiddlyweb.model.bag.Bag>` (the bag itself, not the tiddlers within).
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = _get_bag(environ, bag_name)
bag.policy.allows(environ['tiddlyweb.usersign'], 'manage')
return send_entity(environ, start_response, bag)
def _determine_recipe(environ):
"""
Interpret URL information to determine the target
recipe and then get it from the store.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
try:
recipe = store.get(recipe)
except NoRecipeError, exc:
raise HTTP404('%s not found, %s' % (recipe.name, exc))
def get(environ, start_response):
"""
Handle ``GET`` on a single bag URI.
Get a representation in some serialization determined by
:py:mod:`tiddlyweb.web.negotiate` of a :py:class:`bag
<tiddlyweb.model.bag.Bag>` (the bag itself, not the tiddlers within).
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = _get_bag(environ, bag_name)
bag.policy.allows(environ['tiddlyweb.usersign'], 'manage')
return send_entity(environ, start_response, bag)
def _determine_recipe(environ):
"""
Interpret URL information to determine the target
recipe and then get it from the store.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
try:
recipe = store.get(recipe)
except NoRecipeError, exc:
raise HTTP404('%s not found, %s' % (recipe.name, exc))
def _determine_recipe(environ):
"""
Interpret URL information to determine the target
recipe and then get it from the store.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
try:
recipe = store.get(recipe)
except NoRecipeError, exc:
raise HTTP404('%s not found, %s' % (recipe.name, exc))
def _determine_recipe(environ):
"""
Interpret URL information to determine the target
recipe and then get it from the store.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
try:
recipe = store.get(recipe)
except NoRecipeError, exc:
raise HTTP404('%s not found, %s' % (recipe.name, exc))
def put(environ, start_response):
"""
Handle ``PUT`` on a single bag URI.
Put a :py:class:`bag <tiddlyweb.model.bag.Bag>` to the server,
meaning the description and policy of the bag, if :py:class:`policy
<tiddlyweb.model.policy.Policy>` allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError as exc:
raise HTTP400('unable to put bag: %s' % exc)
except TypeError:
raise HTTP400('Content-type header required')
except NoSerializationError:
raise HTTP415('Content type not supported: %s' % serialize_type)
start_response("204 No Content",
[('Location', web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
bag.skinny = True
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
try:
delattr(bag, 'skinny')
except AttributeError:
pass
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except TypeError:
raise HTTP400('Content-type header required')
except NoSerializationError:
raise HTTP415('Content type not supported: %s' % serialize_type)
start_response("204 No Content",
[('Location', web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Handle ``PUT`` on a single bag URI.
Put a :py:class:`bag <tiddlyweb.model.bag.Bag>` to the server,
meaning the description and policy of the bag, if :py:class:`policy
<tiddlyweb.model.policy.Policy>` allows.
"""
bag_name = web.get_route_value(environ, 'bag_name')
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
bag = store.get(bag)
bag.policy.allows(usersign, 'manage')
except NoBagError:
create_policy_check(environ, 'bag', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
bag.policy.owner = usersign['name']
_validate_bag(environ, bag)
store.put(bag)
except BagFormatError as exc:
raise HTTP400('unable to put bag: %s' % exc)
except TypeError:
raise HTTP400('Content-type header required')
except NoSerializationError:
raise HTTP415('Content type not supported: %s' % serialize_type)
start_response("204 No Content", [('Location', web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ["wsgiorg.routing_args"][1]["recipe_name"]
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, "utf-8")
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ["tiddlyweb.store"]
length = environ["CONTENT_LENGTH"]
usersign = environ["tiddlyweb.usersign"]
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, "manage")
except NoRecipeError:
create_policy_check(environ, "recipe", usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ["wsgi.input"].read(int(length))
serializer.from_string(content.decode("utf-8"))
recipe.policy.owner = usersign["name"]
_validate_recipe(environ, recipe)
store.put(recipe)
except TypeError:
raise HTTP400("Content-type header required")
except NoSerializationError:
raise HTTP415("Content type %s not supported" % serialize_type)
start_response("204 No Content", [("Location", web.recipe_url(environ, recipe))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError, exc:
raise HTTP400('unable to put recipe: %s' % exc)
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError, exc:
raise HTTP400('unable to put recipe: %s' % exc)
def put(environ, start_response):
"""
Put a bag to the server, meaning the description and
policy of the bag, if policy allows.
"""
bag_name = _determine_bag_name(environ)
bag_name = web.handle_extension(environ, bag_name)
bag = Bag(bag_name)
store = environ["tiddlyweb.store"]
length = environ["CONTENT_LENGTH"]
usersign = environ["tiddlyweb.usersign"]
try:
bag.skinny = True
bag = store.get(bag)
bag.policy.allows(usersign, "manage")
delattr(bag, "skinny")
except NoBagError:
create_policy_check(environ, "bag", usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = bag
content = environ["wsgi.input"].read(int(length))
serializer.from_string(content.decode("utf-8"))
bag.policy.owner = usersign["name"]
store.put(bag)
except NoSerializationError:
raise HTTP415("Content type not supported: %s" % serialize_type)
start_response("204 No Content", [("Location", web.bag_url(environ, bag))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = environ['wsgiorg.routing_args'][1]['recipe_name']
recipe_name = urllib.unquote(recipe_name)
recipe_name = unicode(recipe_name, 'utf-8')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length = environ['CONTENT_LENGTH']
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = environ['wsgi.input'].read(int(length))
serializer.from_string(content.decode('UTF-8'))
store.put(recipe)
except NoSerializationError:
raise HTTP415('Content type %s not supported' % serialize_type)
start_response("204 No Content",
[('Location', web.recipe_url(environ, recipe))])
return []
def put(environ, start_response):
"""
Put a new recipe to the server.
"""
recipe_name = web.get_route_value(environ, 'recipe_name')
recipe_name = web.handle_extension(environ, recipe_name)
recipe = Recipe(recipe_name)
store = environ['tiddlyweb.store']
length, _ = web.content_length_and_type(environ)
usersign = environ['tiddlyweb.usersign']
try:
recipe = store.get(recipe)
recipe.policy.allows(usersign, 'manage')
except NoRecipeError:
create_policy_check(environ, 'recipe', usersign)
try:
serialize_type = web.get_serialize_type(environ)[0]
except TypeError:
raise HTTP400('Content-type header required')
try:
serializer = Serializer(serialize_type, environ)
serializer.object = recipe
content = web.read_request_body(environ, length)
serializer.from_string(content.decode('utf-8'))
recipe.policy.owner = usersign['name']
_validate_recipe(environ, recipe)
store.put(recipe)
except RecipeFormatError, exc:
raise HTTP400('unable to put recipe: %s' % exc)