def get_tiddlers(environ, start_response):
"""
Get a list representation of the tiddlers in a
bag. The information sent is dependent on the
serialization chosen.
"""
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
bag_name = web.get_route_value(environ, 'bag_name')
bag = _get_bag(environ, bag_name)
title = 'Tiddlers From Bag %s' % bag.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
usersign = environ['tiddlyweb.usersign']
# will raise exception if there are problems
bag.policy.allows(usersign, 'read')
tiddlers = Tiddlers(title=title)
if not filters:
tiddlers.store = store
tiddlers.bag = bag_name
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
tiddlers.link = '%s/tiddlers' % web.bag_url(environ, bag, full=False)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def get_tiddlers(environ, start_response):
"""
Get a list representation of the tiddlers in a
bag. The information sent is dependent on the
serialization chosen.
"""
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
bag_name = web.get_route_value(environ, 'bag_name')
bag = _get_bag(environ, bag_name)
title = 'Tiddlers From Bag %s' % bag.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
usersign = environ['tiddlyweb.usersign']
# will raise exception if there are problems
bag.policy.allows(usersign, 'read')
if filters:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
tiddlers.link = '%s/tiddlers' % web.bag_url(environ, bag, full=False)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def get(environ, start_response):
"""
Perform a search on the store. What search
means and what results are returned is dependent
on the search implementation (if any) in the
chosen store.
"""
store = environ['tiddlyweb.store']
tiddlers = get_tiddlers(environ)
usersign = environ['tiddlyweb.usersign']
tmp_bag = Bag('tmp_bag', tmpbag=True, searchbag=True)
bag_readable = {}
for tiddler in tiddlers:
try:
if bag_readable[tiddler.bag]:
tmp_bag.add_tiddler(store.get(tiddler))
except KeyError:
bag = Bag(tiddler.bag)
bag.skinny = True
bag = store.get(bag)
try:
bag.policy.allows(usersign, 'read')
tmp_bag.add_tiddler(store.get(tiddler))
bag_readable[tiddler.bag] = True
except(ForbiddenError, UserRequiredError):
bag_readable[tiddler.bag] = False
return send_tiddlers(environ, start_response, tmp_bag)
def whoosher_search(environ, start_response):
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
search_query = get_search_query(environ)
title = 'Search for %s' % search_query
title = environ['tiddlyweb.query'].get('title', [title])[0]
try:
tiddlers = whoosh_search(environ)
usersign = environ['tiddlyweb.usersign']
if filters:
candidate_tiddlers = Tiddlers(title=title)
else:
candidate_tiddlers = Tiddlers(title=title, store=store)
candidate_tiddlers.is_search = True
for tiddler in readable_tiddlers_by_bag(store, tiddlers, usersign):
candidate_tiddlers.add(tiddler)
except StoreMethodNotImplemented:
raise HTTP400('Search system not implemented')
except StoreError as exc:
raise HTTP400('Error while processing search: %s' % exc)
return send_tiddlers(environ, start_response, tiddlers=candidate_tiddlers)
def get_tiddlers(environ, start_response):
"""
Handle ``GET`` on a tiddlers-within-a-recipe URI.
Get a list representation of the :py:class:`tiddlers
<tiddlyweb.model.tiddler.Tiddler>` generated from a :py:class:`recipe
<tiddlyweb.model.recipe.Recipe>`.
The information sent is dependent on the serialization chosen
via :py:mod:`tiddlyweb.web.negotiate`.
"""
usersign = environ['tiddlyweb.usersign']
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
recipe = _determine_recipe(environ)
title = 'Tiddlers From Recipe %s' % recipe.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
# check the recipe can be read
recipe.policy.allows(usersign, 'read')
# check the bags in the recipe can be read
try:
template = control.recipe_template(environ)
for bag_name, _ in recipe.get_recipe(template):
bag = Bag(bag_name)
bag = store.get(bag)
bag.policy.allows(usersign, 'read')
except NoBagError as exc:
raise HTTP404('recipe %s lists an unknown bag: %s' %
(recipe.name, exc))
# from this point forward we know the tiddlers are
# readable
# get the tiddlers from the recipe and uniquify them
try:
candidate_tiddlers = control.get_tiddlers_from_recipe(recipe, environ)
except NoBagError as exc:
raise HTTP404('recipe %s lists an unknown bag: %s' %
(recipe.name, exc))
except FilterError as exc:
raise HTTP400('malformed filter: %s' % exc)
tiddlers = Tiddlers(title=title)
if not filters:
tiddlers.store = store
tiddlers.recipe = recipe.name
for tiddler in candidate_tiddlers:
tiddler.recipe = recipe.name
tiddlers.add(tiddler)
tiddlers.link = '%s/tiddlers' % web.recipe_url(environ, recipe,
full=False)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def tagged_tiddlers(environ, start_response):
store = environ['tiddlyweb.store']
bag_name = unicode(urllib.unquote(environ['wsgiorg.routing_args'][1]['bag_name']), 'utf-8')
tag_name = unicode(urllib.unquote(environ['wsgiorg.routing_args'][1]['tag_name']), 'utf-8')
bag = store.get(Bag(bag_name))
tmp_bag = Bag('tmpbag', tmpbag=True)
tmp_bag.add_tiddlers(control.filter_tiddlers_from_bag(bag, 'select=tag:%s' % tag_name))
return send_tiddlers(environ, start_response, tmp_bag)
def get_tiddlers(environ, start_response):
"""
Handle ``GET`` on a tiddlers-within-a-recipe URI.
Get a list representation of the :py:class:`tiddlers
<tiddlyweb.model.tiddler.Tiddler>` generated from a :py:class:`recipe
<tiddlyweb.model.recipe.Recipe>`.
The information sent is dependent on the serialization chosen
via :py:mod:`tiddlyweb.web.negotiate`.
"""
usersign = environ['tiddlyweb.usersign']
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
recipe = _determine_recipe(environ)
title = 'Tiddlers From Recipe %s' % recipe.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
# check the recipe can be read
recipe.policy.allows(usersign, 'read')
# check the bags in the recipe can be read
try:
template = control.recipe_template(environ)
for bag_name, _ in recipe.get_recipe(template):
bag = Bag(bag_name)
bag = store.get(bag)
bag.policy.allows(usersign, 'read')
except NoBagError as exc:
raise HTTP404('recipe %s lists an unknown bag: %s' %
(recipe.name, exc))
# from this point forward we know the tiddlers are
# readable
# get the tiddlers from the recipe and uniquify them
try:
candidate_tiddlers = control.get_tiddlers_from_recipe(recipe, environ)
except NoBagError as exc:
raise HTTP404('recipe %s lists an unknown bag: %s' %
(recipe.name, exc))
except FilterError as exc:
raise HTTP400('malformed filter: %s' % exc)
tiddlers = Tiddlers(title=title)
if not filters:
tiddlers.store = store
tiddlers.recipe = recipe.name
for tiddler in candidate_tiddlers:
tiddler.recipe = recipe.name
tiddlers.add(tiddler)
tiddlers.link = '%s/tiddlers' % web.recipe_url(environ, recipe, full=False)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def get_request(environ, start_response):
query = environ["tiddlyweb.query"]
tiddler_count = query.get("tiddlers", [default_tiddler_count])[0]
store = Storage("datagenerator", {})
bag = Bag(str(tiddler_count))
bag = store.get(bag)
# populate tiddlers in bag
for tiddler in bag.list_tiddlers():
store.get(tiddler)
return send_tiddlers(environ, start_response, bag)
def get(environ, start_response):
"""
Perform a search on the store. What search
means and what results are returned is dependent
on the search implementation (if any) in the
chosen store.
"""
try:
search_query = environ['tiddlyweb.query']['q'][0]
search_query = urllib.unquote(search_query)
search_query = unicode(search_query, 'utf-8')
except (KeyError, IndexError):
raise HTTP400('query string required')
filters = environ['tiddlyweb.filters']
store = environ['tiddlyweb.store']
try:
tiddlers = store.search(search_query)
except StoreMethodNotImplemented:
raise HTTP400('Search system not implemented')
usersign = environ['tiddlyweb.usersign']
# It's necessary to get the tiddler off the store
# in case we are doing wiki or atom outputs of the
# search.
tmp_bag = Bag('tmp_bag', tmpbag=True, searchbag=True)
bag_readable = {}
for tiddler in tiddlers:
try:
if bag_readable[tiddler.bag]:
tmp_bag.add_tiddler(store.get(tiddler))
except KeyError:
bag = Bag(tiddler.bag)
bag.skinny = True
bag = store.get(bag)
try:
bag.policy.allows(usersign, 'read')
tmp_bag.add_tiddler(store.get(tiddler))
bag_readable[tiddler.bag] = True
except(ForbiddenError, UserRequiredError):
bag_readable[tiddler.bag] = False
if len(filters):
tiddlers = control.filter_tiddlers_from_bag(tmp_bag, filters)
tmp_bag = Bag('tmp_bag', tmpbag=True)
tmp_bag.add_tiddlers(tiddlers)
return send_tiddlers(environ, start_response, tmp_bag)
def get_tiddlers(environ, start_response):
"""
Get a list representation of the tiddlers in a
bag. The information sent is dependent on the
serialization chosen.
"""
bag_name = _determine_bag_name(environ)
bag = _get_bag(environ, bag_name, True)
usersign = environ['tiddlyweb.usersign']
# will raise exception if there are problems
bag.policy.allows(usersign, 'read')
return send_tiddlers(environ, start_response, bag)
def tagged_tiddlers(environ, start_response):
store = environ['tiddlyweb.store']
bag_name = unicode(
urllib.unquote(environ['wsgiorg.routing_args'][1]['bag_name']),
'utf-8')
tag_name = unicode(
urllib.unquote(environ['wsgiorg.routing_args'][1]['tag_name']),
'utf-8')
bag = store.get(Bag(bag_name))
tmp_bag = Bag('tmpbag', tmpbag=True)
tmp_bag.add_tiddlers(
control.filter_tiddlers_from_bag(bag, 'select=tag:%s' % tag_name))
return send_tiddlers(environ, start_response, tmp_bag)
def user_page(environ, start_response):
print(environ)
name = environ['wsgiorg.routing_args'][1].get('name', 'default')
recipe = Recipe('tmp')
recipe.set_recipe([
[name, '']
])
# establish the store on the recipe so that get_tiddlers_from_recipe
# will load the bags and their tiddler lists from the store
recipe.store = environ['tiddlyweb.store']
tiddlers = control.get_tiddlers_from_recipe(recipe, environ)
bag = Bag('tmp', tmpbag=True)
bag.add_tiddlers(tiddlers)
return send_tiddlers(environ, start_response, bag)
def public_stuff(environ, start_response):
"""
A collection of the most recent stuff.
A place where _all_ the content readable
by the current user can be viewed.
"""
user = get_user_object(environ)
store = environ['tiddlyweb.store']
kept_bags = get_stuff(store, store.list_bags(), user)
tiddlers = Tiddlers()
for bag in kept_bags:
bag = store.get(bag)
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def get_tiddlers(environ, start_response):
"""
Get a list representation of the tiddlers in a
bag. The information sent is dependent on the
serialization chosen.
"""
store = environ["tiddlyweb.store"]
bag_name = _determine_bag_name(environ)
bag = _get_bag(environ, bag_name)
usersign = environ["tiddlyweb.usersign"]
# will raise exception if there are problems
bag.policy.allows(usersign, "read")
return send_tiddlers(environ, start_response, tiddlers=store.list_bag_tiddlers(bag))
def public_stuff(environ, start_response):
"""
A collection of the most recent stuff.
A place where _all_ the content readable
by the current user can be viewed.
"""
user = get_user_object(environ)
store = environ['tiddlyweb.store']
kept_bags = get_stuff(store, store.list_bags(), user)
tiddlers = Tiddlers()
for bag in kept_bags:
bag = store.get(bag)
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def dyna(environ, start_response):
name = environ['wsgiorg.routing_args'][1].get('name', 'default')
username = environ['tiddlyweb.usersign']['name']
recipe = Recipe('tmp')
recipe.set_recipe([
[BASE_BAG_NAME, ''],
[name, ''],
[username, '']
])
# establish the store on the recipe so that get_tiddlers_from_recipe
# will load the bags and their tiddler lists from the store
recipe.store = environ['tiddlyweb.store']
tiddlers = control.get_tiddlers_from_recipe(recipe, environ)
bag = Bag('tmp', tmpbag=True)
bag.add_tiddlers(tiddlers)
return send_tiddlers(environ, start_response, bag)
def get_tiddlers(environ, start_response):
"""
Get a list representation of the tiddlers in a
bag. The information sent is dependent on the
serialization chosen.
"""
store = environ['tiddlyweb.store']
bag_name = _determine_bag_name(environ)
bag = _get_bag(environ, bag_name)
title = 'Tiddlers From Bag %s' % bag.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
usersign = environ['tiddlyweb.usersign']
# will raise exception if there are problems
bag.policy.allows(usersign, 'read')
tiddlers = Tiddlers(title=title, store=store)
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
container = 'recipes' if tiddler.recipe else 'bags'
if environ['tiddlyweb.filters']:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
tiddlers.link = '%s/revisions' % tiddler_url(environ, tiddler,
container=container, full=False)
# Set the container on the tiddlers. Since tiddler.recipe
# defaults to None, we're "safe" here.
tiddlers.recipe = tiddler.recipe
tiddlers.bag = tiddler.bag
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
tmp_tiddler.recipe = tiddler.recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError as exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
except NoBagError as exc:
raise HTTP404('tiddler %s not found, bag %s does not exist, %s'
% (tiddler.title, tiddler.bag, exc))
except StoreMethodNotImplemented:
raise HTTP400('no revision support')
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def _send_tiddler_revisions(environ, start_response, tiddler):
"""
Push the list of tiddler revisions out the network.
"""
store = environ['tiddlyweb.store']
title = 'Revisions of Tiddler %s' % tiddler.title
title = environ['tiddlyweb.query'].get('title', [title])[0]
container = 'recipes' if tiddler.recipe else 'bags'
if environ['tiddlyweb.filters']:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
tiddlers.is_revisions = True
tiddlers.link = '%s/revisions' % tiddler_url(environ, tiddler,
container=container, full=False)
# Set the container on the tiddlers. Since tiddler.recipe
# defaults to None, we're "safe" here.
tiddlers.recipe = tiddler.recipe
tiddlers.bag = tiddler.bag
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
tmp_tiddler.recipe = tiddler.recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError as exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
except NoBagError as exc:
raise HTTP404('tiddler %s not found, bag %s does not exist, %s'
% (tiddler.title, tiddler.bag, exc))
except StoreMethodNotImplemented:
raise HTTP400('no revision support')
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def get_tiddlers(environ, start_response):
"""
Handle ``GET`` on a tiddlers-within-a-bag URI.
Get a list representation of the :py:class:`tiddlers
<tiddlyweb.model.tiddler.Tiddler>` in a :py:class:`bag
<tiddlyweb.model.bag.Bag>`.
The information sent is dependent on the serialization chosen
via :py:mod:`tiddlyweb.web.negotiate`.
"""
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
bag_name = web.get_route_value(environ, 'bag_name')
bag = _get_bag(environ, bag_name)
title = 'Tiddlers From Bag %s' % bag.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
usersign = environ['tiddlyweb.usersign']
# will raise exception if there are problems
bag.policy.allows(usersign, 'read')
tiddlers = Tiddlers(title=title)
if not filters:
tiddlers.store = store
tiddlers.bag = bag_name
# A special bag can raise NoBagError here.
try:
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
except NoBagError as exc:
raise HTTP404('%s not found, %s' % (bag.name, exc))
tiddlers.link = '%s/tiddlers' % web.bag_url(environ, bag, full=False)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def get_tiddlers(environ, start_response):
"""
Handle ``GET`` on a tiddlers-within-a-bag URI.
Get a list representation of the :py:class:`tiddlers
<tiddlyweb.model.tiddler.Tiddler>` in a :py:class:`bag
<tiddlyweb.model.bag.Bag>`.
The information sent is dependent on the serialization chosen
via :py:mod:`tiddlyweb.web.negotiate`.
"""
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
bag_name = web.get_route_value(environ, 'bag_name')
bag = _get_bag(environ, bag_name)
title = 'Tiddlers From Bag %s' % bag.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
usersign = environ['tiddlyweb.usersign']
# will raise exception if there are problems
bag.policy.allows(usersign, 'read')
tiddlers = Tiddlers(title=title)
if not filters:
tiddlers.store = store
tiddlers.bag = bag_name
# A special bag can raise NoBagError here.
try:
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.add(tiddler)
except NoBagError as exc:
raise HTTP404('%s not found, %s' % (bag.name, exc))
tiddlers.link = '%s/tiddlers' % web.bag_url(environ, bag, full=False)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def get(environ, start_response):
"""
Handle ``GET`` on the search URI.
Perform a search against the :py:class:`store <tiddlyweb.store.Store>`.
What search means and what results are returned is dependent
on the search implementation (if any) in the :py:class:`chosen store
<tiddlyweb.stores.StorageInterface>`.
"""
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
search_query = get_search_query(environ)
title = 'Search for %s' % search_query
title = environ['tiddlyweb.query'].get('title', [title])[0]
try:
tiddlers = get_tiddlers(environ)
usersign = environ['tiddlyweb.usersign']
if filters:
candidate_tiddlers = Tiddlers(title=title)
else:
candidate_tiddlers = Tiddlers(title=title, store=store)
candidate_tiddlers.is_search = True
for tiddler in readable_tiddlers_by_bag(store, tiddlers, usersign):
candidate_tiddlers.add(tiddler)
except StoreMethodNotImplemented:
raise HTTP400('Search system not implemented')
except StoreError as exc:
raise HTTP400('Error while processing search: %s' % exc)
return send_tiddlers(environ, start_response, tiddlers=candidate_tiddlers)
def get(environ, start_response):
"""
Handle ``GET`` on the search URI.
Perform a search against the :py:class:`store <tiddlyweb.store.Store>`.
What search means and what results are returned is dependent
on the search implementation (if any) in the :py:class:`chosen store
<tiddlyweb.stores.StorageInterface>`.
"""
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
search_query = get_search_query(environ)
title = 'Search for %s' % search_query
title = environ['tiddlyweb.query'].get('title', [title])[0]
try:
tiddlers = get_tiddlers(environ)
usersign = environ['tiddlyweb.usersign']
if filters:
candidate_tiddlers = Tiddlers(title=title)
else:
candidate_tiddlers = Tiddlers(title=title, store=store)
candidate_tiddlers.is_search = True
for tiddler in readable_tiddlers_by_bag(store, tiddlers, usersign):
candidate_tiddlers.add(tiddler)
except StoreMethodNotImplemented:
raise HTTP400('Search system not implemented')
except StoreError as exc:
raise HTTP400('Error while processing search: %s' % exc)
return send_tiddlers(environ, start_response, tiddlers=candidate_tiddlers)
def form(environ, start_response):
"""
Produce this named form to the web.
"""
store = environ['tiddlyweb.store']
bag_id = environ['wsgiorg.routing_args'][1]['formid']
recipe_id, uuid = bag_id.rsplit('.', 1)
logging.debug('getting form with bag %s using recipe %s' % (bag_id, recipe_id))
bag = store.get(Bag(bag_id))
_process_config_tiddler(store, bag)
recipe = store.get(Recipe(recipe_id))
base_tiddlers = control.get_tiddlers_from_recipe(recipe)
# read the bag (again) to make sure we have all the tiddlers
bag = store.get(bag)
data_tiddlers = bag.list_tiddlers()
tiddlers = base_tiddlers + data_tiddlers
tmp_bag = Bag('tmp', tmpbag=True)
for tiddler in tiddlers:
store.get(tiddler)
tmp_bag.add_tiddler(tiddler)
logging.debug(['%s:%s' % (tiddler.bag, tiddler.title) for tiddler in tmp_bag.list_tiddlers()])
environ['tiddlyweb.type'] = 'text/x-tiddlywiki'
return send_tiddlers(environ, start_response, tmp_bag)
(recipe.name, exc))
except FilterError, exc:
raise HTTP400('malformed filter: %s' % exc)
if filters:
tiddlers = Tiddlers(title=title)
else:
tiddlers = Tiddlers(title=title, store=store)
for tiddler in candidate_tiddlers:
tiddler.recipe = recipe.name
tiddlers.add(tiddler)
tiddlers.link = '%s/tiddlers' % web.recipe_url(environ, recipe, full=False)
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def list_recipes(environ, start_response):
"""
Get a list of all recipes the current user can read.
"""
store = environ['tiddlyweb.store']
serialize_type, mime_type = web.get_serialize_type(environ)
serializer = Serializer(serialize_type, environ)
return list_entities(environ, start_response, mime_type,
store.list_recipes, serializer.list_recipes)
def put(environ, start_response):
"""
container=container, full=False)
recipe = tiddler.recipe
try:
for revision in store.list_tiddler_revisions(tiddler):
tmp_tiddler = Tiddler(title=tiddler.title, bag=tiddler.bag)
tmp_tiddler.revision = revision
if recipe:
tmp_tiddler.recipe = recipe
tiddlers.add(tmp_tiddler)
except NoTiddlerError, exc:
# If a tiddler is not present in the store.
raise HTTP404('tiddler %s not found, %s' % (tiddler.title, exc))
except NoBagError, exc:
raise HTTP404('tiddler %s not found, bag %s does not exist, %s'
% (tiddler.title, tiddler.bag, exc))
except StoreMethodNotImplemented:
raise HTTP400('no revision support')
return send_tiddlers(environ, start_response, tiddlers=tiddlers)
def _new_tiddler_etag(tiddler):
"""
Calculate the ETag of a tiddler that does not
yet exist. This is a bastardization of ETag handling
but is useful for doing edit contention handling.
"""
return str('"%s/%s/%s"' % (web.encode_name(tiddler.bag),
web.encode_name(tiddler.title), '0'))
def get(environ, start_response):
"""
Perform a search on the store. What search
means and what results are returned is dependent
on the search implementation (if any) in the
chosen store.
"""
store = environ['tiddlyweb.store']
search_query = get_search_query(environ)
title = 'Search for %s' % search_query
title = environ['tiddlyweb.query'].get('title', [title])[0]
try:
tiddlers = get_tiddlers(environ)
usersign = environ['tiddlyweb.usersign']
candidate_tiddlers = Tiddlers(title=title, store=store)
candidate_tiddlers.is_search = True
for tiddler in readable_tiddlers_by_bag(store, tiddlers, usersign):
candidate_tiddlers.add(tiddler)
except StoreMethodNotImplemented:
raise HTTP400('Search system not implemented')
except StoreError, exc:
raise HTTP400('Error while processing search: %s' % exc)
return send_tiddlers(environ, start_response, tiddlers=candidate_tiddlers)
policies = {}
for tiddler in tiddlers:
bag_name = tiddler.bag
try:
policies[bag_name].allows(usersign, 'read')
except KeyError:
bag = Bag(tiddler.bag)
bag = store.get(bag)
policy = bag.policy
policies[bag_name] = policy
policies[bag_name].allows(usersign, 'read')
tiddler.recipe = recipe.name
tmp_bag.add_tiddler(tiddler)
return send_tiddlers(environ, start_response, tmp_bag)
def list(environ, start_response):
"""
Get a list of all recipes the current user can read.
"""
store = environ['tiddlyweb.store']
recipes = store.list_recipes()
kept_recipes = []
for recipe in recipes:
try:
recipe = store.get(recipe)
recipe.policy.allows(environ['tiddlyweb.usersign'], 'read')
kept_recipes.append(recipe)
except(UserRequiredError, ForbiddenError):
try:
rule =environ['tiddlyweb.config']['tiddlyeditor_recipe']
recipe = create_dynamic_recipe(environ,rule)
tiddlers = control.get_tiddlers_from_recipe(recipe)
for tid in tiddlers:
output_bag.add_tiddler(tid)
except KeyError:
for required_tiddler in environ['tiddlyweb.config'].get('tiddlyeditor_tiddlers', []):
r_tiddler = Tiddler(required_tiddler[1], required_tiddler[0])
r_tiddler = store.get(r_tiddler)
if 'excludeLists' not in r_tiddler.tags:
r_tiddler.tags.append('excludeLists')
output_bag.add_tiddler(r_tiddler)
environ['tiddlyweb.type'] = 'text/x-tiddlywiki'
return send_tiddlers(environ, start_response, output_bag)
original_footer_extra = HTMLPresenter.footer_extra
def edit_link(self, environ):
output = original_footer_extra(self, environ)
if 'tiddlyeditor_tiddlers' in environ['tiddlyweb.config']:
tiddler_name = environ['wsgiorg.routing_args'][1].get('tiddler_name', None)
recipe_name = environ['wsgiorg.routing_args'][1].get('recipe_name', '')
bag_name = environ['wsgiorg.routing_args'][1].get('bag_name', '')
revision = environ['wsgiorg.routing_args'][1].get('revision', None)
server_prefix = environ['tiddlyweb.config']['server_prefix']
if tiddler_name and not revision:
return output + '<div id="edit"><a href="%s/tiddlyeditor?tiddler=%s;bag=%s;recipe=%s">TiddlyEdit</a></div>' \
'[[Back to TiddlyWeb|%s]]' % tiddler_url(environ, tiddler))
add_magic_tiddler(output_bag, 'DefaultTiddlers', '[[%s]]' % tiddler_name)
add_magic_tiddler(output_bag, 'SiteTitle', 'Editor for %s' % tiddler_name)
add_magic_tiddler(output_bag, 'SiteSubtitle', '')
add_magic_tiddler(output_bag, 'SideBarOptions', '')
for required_tiddler in environ['tiddlyweb.config'].get(
'tiddlyeditor_tiddlers', []):
r_tiddler = Tiddler(required_tiddler[1], required_tiddler[0])
r_tiddler = store.get(r_tiddler)
if 'excludeLists' not in r_tiddler.tags:
r_tiddler.tags.append('excludeLists')
output_bag.add_tiddler(r_tiddler)
environ['tiddlyweb.type'] = 'text/x-tiddlywiki'
return send_tiddlers(environ, start_response, output_bag)
original_footer_extra = HTMLPresenter.footer_extra
def edit_link(self, environ):
output = original_footer_extra(self, environ)
if 'tiddlyeditor_tiddlers' in environ['tiddlyweb.config']:
tiddler_name = environ['wsgiorg.routing_args'][1].get(
'tiddler_name', None)
recipe_name = environ['wsgiorg.routing_args'][1].get('recipe_name', '')
bag_name = environ['wsgiorg.routing_args'][1].get('bag_name', '')
revision = environ['wsgiorg.routing_args'][1].get('revision', None)
server_prefix = environ['tiddlyweb.config']['server_prefix']
