def reorder(self, id, **params):
if getparam('cancel') == '1':
redirect(url("coll-view", id=id))
coll = get_or_404(Collection, id)
context = {}
if cherrypy.request.method == "POST":
# FIXME - check csrf token
order, ordering = coll_order_from_request()
if getparam('submit') == '1':
# save order
coll.autoorder.ordering = ordering
Collection.objects.set(coll)
Collection.objects.flush()
redirect(url("coll-view", id=id))
else:
order = []
for field, dir in coll.autoorder.ordering:
order.append((len(order), field, dir))
if not order:
order.append((0, '', ''))
context['coll'] = coll
context['collorder'] = order
return render("coll-reorder.html", context)
def coll_parents_from_request():
parents = []
for num in getorderparam('order'):
parent = getparam('parent%d' % num)
if parent is None or parent == '':
continue
if getparam('del%d' % num) == '1':
continue
parents.append(unicode(parent))
if getparam('add') == '1':
parents.append(u'')
return parents
def handle_post(self, params, context):
context.update(self.build_form_context(params))
do_import = getparam('import', None, None, params)
if do_import:
self.set_next(BuildExploratourRecordsTask(self.handler, self.importer))
redirect(url("import", id=self.importer.id))
return render("import/choose-fields.html", context)
def create(self, **params):
context = {}
if cherrypy.request.method == "POST":
# FIXME - check csrf token
title = params.get('newcoll_title', u'').strip()
parents = coll_parents_from_request()
if getparam('create'):
if title:
id = create_collection(title, parents)
gonext()
redirect(url("colls-list", id=id))
else:
context['error'] = "You must set a title for the collection"
else:
parents = []
allowable_parents = set(
c.id for c in Collection.objects
)
context.update(dict(
parents = tuple(enumerate(parents)),
allowable_parents = sorted(allowable_parents),
collections = Collection.objects,
))
return render("coll-new.html", context)
def handle_post(self, params, context):
context.update(self.build_form_context(params))
do_import = getparam('import', None, None, params)
if do_import:
self.set_next(ImportPerformTask(self.handler, self.importer))
redirect(url("import", id=self.importer.id))
return render("import/choose-mappings.html", context)
def imp(self, **params):
stash = {}
# Get any existing Importer
imp = None
imp_id = getintparam("id", None, stash, params)
if imp_id is not None:
imp = self.imports.get(imp_id, None)
if imp is None:
context = {}
context['error'] = 'Unknown import ID'
return render("import/choose-file.html", context)
if imp is None:
# No import in progress
if cherrypy.request.method == "POST":
return self.handle_import_start(params)
elif cherrypy.request.method == "GET":
return render("import/choose-file.html", {})
else:
# Import in progress; let it handle the request.
if cherrypy.request.method == "POST":
if getparam("import_cancel", None):
imp.cancel()
redirect(url("home"))
return imp.handle_post(params)
elif cherrypy.request.method == "GET":
return imp.handle_get(params)
raise cherrypy.NotFound
def record_from_simple_request(params):
# Iterate through the parameters in order, getting the values and adding
# them to the record. The stack is used for groups.
result = Record()
ordering = map(int, filter(lambda x: x != '', getparam('ordering', '', params=params).split(',')))
stack = [dict(item=result.root, repeat=False, remove=False, num=None)]
for num in ordering:
item = RecordItem_from_form(num, params=params)
repeat = (getparam('repeat_%d' % num, '', params=params) != '')
remove = (getparam('remove_%d' % num, '', params=params) != '')
if item.tag == u'field':
if remove:
continue
indent_previous(stack)
elt = item.get_elt()
stack[-1]['item'].append(elt)
if repeat:
# Special case for the "display" attribute - preserve it, for
# file fields.
newelt = copy_elt_without_values(elt, keep=('display',))
indent_previous(stack)
stack[-1]['item'].append(newelt)
elif item.tag == u'group':
if num == stack[-1]['num']:
if len(stack) <= 1:
raise ValidationError("More groups closed than opened")
indent_previous(stack, -1)
if stack[-1]['remove']:
del stack[-2]['item'][-1]
elif stack[-1]['repeat']:
# Repeat this element.
newgroup = copy_elt_without_values(stack[-1]['item'])
indent_previous(stack[:-1])
stack[-2]['item'].append(newgroup)
del stack[-1]
else:
indent_previous(stack)
elt = item.get_elt()
stack[-1]['item'].append(elt)
stack.append(dict(item=elt, repeat=repeat, remove=remove,
num=num))
return result
def reparent(self, id, **params):
if getparam('cancel') == '1':
redirect(url("coll-view", id=id))
coll = get_or_404(Collection, id)
if cherrypy.request.method == "POST":
# FIXME - check csrf token
title = getparam('title')
parents = coll_parents_from_request()
if getparam('submit') == '1':
# Save parents
changed = coll.set_parents(filter(lambda x: x != '', parents))
if coll.title != title:
coll.title = title
Collection.objects.set(coll)
Collection.objects.flush()
Record.objects.flush()
redirect(url("coll-view", id=id))
else:
title = coll.title
parents = []
for parent in coll.parents:
parents.append(parent)
if not parents:
parents.append('')
not_allowed = set(coll.ancestors) - set(coll.parents)
not_allowed.add(id)
allowable_parents = set(
c.id for c in Collection.objects
if c.id != id and id not in c.ancestors
)
context = dict(
title = title,
coll = coll,
parents = tuple(enumerate(parents)),
allowable_parents = sorted(allowable_parents),
collections = Collection.objects,
)
return render("coll-reparent.html", context)
def coll_order_from_request():
order = []
ordering = []
# Read collection order from request.
for num in getorderparam('order'):
field = getparam('field%d' % num)
dir = getparam('dir%d' % num)
if field is None or '_' not in field or dir is None:
continue
if getparam('del%d' % num) == '1':
continue
order.append((len(order), field, dir))
ordering.append((field, dir))
if getparam('add') == '1':
order.append((len(order), '', ''))
return order, ordering
def read_params(self, stash, params):
self.collid = getparam('coll', None, stash, params)
self.incmedia = getparam('incmedia', 'include', stash, params)
self.mediabase = getparam('mediabase', '', stash, params)
self.frontpage = None
if self.collid:
types_available, dates_available = self.types_in_collection(self.collid)
coll = Collection.objects.get(self.collid)
if coll is not None:
allowed_ancestors = self.allowed_ancestors(coll)
maintab = self.coll_maintab(coll, types_available, dates_available,
allowed_ancestors)
if not coll.has_children:
subs = 'coll'
else:
subs = 'all'
self.frontpage = 'coll/%s/%s/detail/%s/index.html' % \
(self.collid, maintab, subs)
def export_backup(self, export_id=None, download=False, **params):
# Read parameters first, to ensure they all get stashed.
stash = {}
# Make a new exporter, and get any parameters it needs into the stash.
exp = Exporter.get('xml')()
exp.read_params(stash, params)
# Handle exports which are in progress, or have finished
if export_id is not None:
try:
export_id = int(export_id)
except ValueError:
export_id = None
if export_id is not None:
try:
running_exp = exports[export_id]
except KeyError:
# Invalid export id (most probably due to a server restart)
running_exp = None
if running_exp is not None:
# Export in progress
progress = pool.get_progress(export_id)
context = dict(export_id=export_id, fmt='xml', progress=progress,
stash=stash)
if not progress.complete:
return render('export/in_progress.html', context)
if progress.failed:
return render('export/failed.html', context)
# Export complete
if not download:
# Display a "Export prepared"
return render('export/complete.html', context)
return running_exp.respond()
# Read the set of things to export.
search, desc, topcoll = self._get_export_records(stash, None, None, None, True)
if not getparam('export', False, stash, params):
# Not ready to start the export yet.
context = dict(
export_desc = desc,
stash = stash,
)
exp.add_to_context(context, search, stash, params)
return render('backup/pick.html', context)
# Start the exporter
task = ExportRecords(exp, search)
export_id = pool.add_task(task)
exports[export_id] = task
redirect(url("records-export-inprogress", export_id=export_id, fmt='xml', **stash))
def handle_import_start(self, params):
"""Handle a POST request that starts an import."""
if getparam("import_cancel", None):
redirect(url("home"))
imp = download.Importer()
imp.start(params)
if imp.error:
context = {}
context['error'] = imp.error
return render("import/choose-file.html", context)
self.imports[imp.id] = imp
redirect(url("import", id=imp.id))
def write_search(self, params):
params = dict(params)
stash = {}
context = dict(stash=stash)
searchparams = SearchParams(stash, params)
search = Search(searchparams, url_fn=self.url)
if self.collid is not None:
search.restrict_to_collection(self.collid)
search.add_to_context(context)
context['showfull'] = int(getparam('showfull', '1', stash, params))
self.render('search', (), params,
"export/html/search.html", context)
def view(self, id, **params):
context = {}
stash = {}
showfull = int(getparam('showfull', '0', stash))
search = build_search(stash)
# FIXME - hack
q = search['q']
q.startrank = 0
q.endrank = 20000
items = q.results
ids = set()
for item in items:
if item.data['type'][0] != 'r': continue
ids.add(item.data['id'][0])
points = []
for id in sorted(ids):
rec = Record.objects.get(unicode(id))
date = rec.root.find("field[@type='date']")
if date is None:
continue
date = date.text
if date is None:
continue
mo = single_full_bamboostyle_date_re.match(date)
if not mo:
continue
day, month, year = map(lambda x: int(x), (mo.group(1), mo.group(2), mo.group(3)))
date = datetime.date(year, month, day)
locs = rec.root.findall(".//field[@type='location']")
for loc in locs:
ll = latlongparse(loc.get('latlong'))
if ll is None:
continue
points.append([ll.lat, ll.long, rec.id, date])
points.sort(key=lambda x: x[3])
startdate = points[0][3]
for i in xrange(len(points)):
days = (points[i][3] - startdate).days
points[i][3] = points[i][3].isoformat()
points[i].append(days)
context['points'] = points
context['center_point'] = [points[0][0], points[0][1], 7]
return render("dataview.html", context)
def list(self, **params):
coll = get_lockto_coll()
if coll is not None:
redirect(url("coll-view", id=coll.id))
groups = [CollGroup(coll.id, coll.title, [coll.id])
for coll in Collection.objects if not coll.parents]
groupid = getparam('groupid', '')
filtered_groups = filter(lambda group: group.id == groupid, groups)
if len(filtered_groups) > 0:
currgroup = filtered_groups[0]
elif len(groups) > 0:
currgroup = groups[0]
else:
currgroup = None
context = dict(groups=groups, currgroup=currgroup)
return render("colls-list.html", context)
def build_form_context(self, params):
context = {}
class Info(object):
def __init__(self, **kwargs):
for k, v in kwargs.items():
setattr(self, k, v)
# Determine how conflicts should be resolved
self.handler.record_conflict_resolution = self.get_conflict_option('record_conflict', params)
context['record_conflict'] = self.handler.record_conflict_resolution
self.handler.coll_conflict_resolution = self.get_conflict_option('coll_conflict', params)
context['coll_conflict'] = self.handler.coll_conflict_resolution
# Get the media root mappings supplied by the client.
media_root_mappings = {}
for num, (root, rootinfo) in enumerate(sorted(self.handler.media_roots.items())):
newroot = getparam('r%d' % num, root, None, params)
rootinfo['newroot'] = newroot
if newroot != root:
media_root_mappings[root] = newroot
self.handler.update_media_root_mappings(media_root_mappings)
# Calculate the info, after the mappings have been applied.
info = Info(filename = self.importer.filename,
records_count = len(self.handler.records),
record_identical = self.handler.record_identical,
record_conflicts = self.handler.record_conflicts,
record_new = self.handler.record_new,
collections = self.handler.collections,
coll_identical = self.handler.coll_identical,
coll_conflicts = self.handler.coll_conflicts,
coll_new = self.handler.coll_new,
media_files_count = len(self.handler.media_paths),
media_roots = enumerate(sorted(self.handler.media_roots.items())),
)
context['info'] = info
context['import_id'] = getintparam("id", None, None, params)
return context
def read_params(self, stash, params):
self.fields = getparamlist("f", None, stash, params)
self.forder = getparam("forder", "record", stash, params)
def export_records(self, export_id=None, fmt='rtf', download=False,
**params):
"""Export a set of records.
"""
# Read parameters first, to ensure they all get stashed.
stash = {}
record_id = getparam('record_id', None, stash, params)
issearch = getparam('issearch', None, stash, params)
coll = getparam('coll', None, stash, params)
incsubs = getintparam('incsubs', 1, stash, params)
# Make a new exporter, and get any parameters it needs into the stash.
try:
exp = Exporter.get(fmt)()
except KeyError:
raise cherrypy.NotFound
exp.read_params(stash, params)
# Handle exports which are in progress, or have finished
if export_id is not None:
try:
export_id = int(export_id)
except ValueError:
export_id = None
if export_id is not None:
try:
running_exp = exports[export_id]
except KeyError:
# Invalid export id (most probably due to a server restart)
running_exp = None
if running_exp is not None:
# Export in progress
progress = pool.get_progress(export_id)
context = dict(export_id=export_id, fmt=fmt, progress=progress,
stash=stash)
if not progress.complete:
return render('export/in_progress.html', context)
if progress.failed:
return render('export/failed.html', context)
# Export complete
if not download:
# Display a "Export prepared"
return render('export/complete.html', context)
return running_exp.respond()
# Read the set of things to export.
search, desc, topcoll = self._get_export_records(stash, record_id, issearch,
coll, incsubs)
if not getparam('export', False, stash, params):
# Not ready to start the export yet.
context = dict(
fmts = Exporter.fmts(params),
fmt = fmt,
export_desc = desc,
stash = stash,
)
exp.add_to_context(context, search, stash, params)
return render('export/pickfmt.html', context)
# Start the exporter
task = ExportRecords(exp, search)
export_id = pool.add_task(task)
exports[export_id] = task
redirect(url("records-export-inprogress", export_id=export_id, fmt=fmt, **stash))
def search(self, **params):
stash = {}
context = dict(stash=stash)
params = SearchParams(stash)
search = Search(params)
if not search.validate():
# If the search doesn't validate, always go to the search entry
# page.
params.action = 'entry'
search.add_to_context(context)
context['showfull'] = int(getparam('showfull', '0', stash))
if params.action == 'search':
return render("search.html", context)
elif params.action == 'select':
return render("search_select.html", context)
elif params.action.startswith('createcoll'):
if cherrypy.request.method != "POST":
return render("search_createcoll.html", context)
subact = params.action[11:]
parents = []
for num in getorderparam('parent_order'):
parent = getparam('parent%d' % num)
if parent is None or parent == '':
continue
if subact == ('del_parent_%d' % num):
continue
parents.append(unicode(parent))
if subact == 'add_parent':
parents.append(u'')
context['parents'] = tuple(enumerate(parents))
context['allowable_parents'] = set(
c.id for c in Collection.objects
)
context['collections'] = Collection.objects
if subact == 'do':
newtitle = getparam('create_colltitle', '')
if len(newtitle) == 0:
context['error'] = "Cannot create collection with no title"
return render("search_createcoll.html", context)
coll = Collection.find_by_title(newtitle)
if len(coll) != 0:
context['error'] = "Collection with title %s already exists" % newtitle
return render("search_createcoll.html", context)
coll = Collection(None, None, newtitle)
Collection.objects.set(coll)
# Have to set the collection before setting the parents, to get
# an ID for the parents to refer back to.
coll.set_parents(filter(lambda x: x != '', parents))
Collection.objects.set(coll)
Record.objects.flush()
Collection.objects.flush()
for record in search.query:
record = record.object
record.collections = record.collections + [coll.id]
Record.objects.set(record)
Record.objects.flush()
Collection.objects.flush()
redirect(url("coll-view", id=coll.id))
else:
return render("search_createcoll.html", context)
elif params.action == 'addtocoll':
context['all_collections'] = Collection.objects
if cherrypy.request.method != "POST":
return render("search_addtocoll.html", context)
newid = getparam('addto_collid', '')
if len(newid) == 0:
context['error'] = "Pick a collection to add to"
return render("search_addtocoll.html", context)
coll = Collection.objects.get(newid)
for record in search.query:
record = record.object
record.collections = record.collections + [coll.id]
Record.objects.set(record)
Record.objects.flush()
Collection.objects.flush()
redirect(url("coll-view", id=coll.id))
return render("search_addtocoll.html", context)
elif params.action == 'removefromcoll':
context['all_collections'] = Collection.objects
if cherrypy.request.method != "POST":
return render("search_removefromcoll.html", context)
newid = getparam('removefrom_collid', '')
if len(newid) == 0:
context['error'] = "Pick a collection to remove from"
return render("search_removefromcoll.html", context)
coll = Collection.objects.get(newid)
for record in search.query:
record = record.object
record.collections = tuple(filter(lambda x: x != coll.id,
record.collections))
Record.objects.set(record)
Record.objects.flush()
Collection.objects.flush()
redirect(url("coll-view", id=coll.id))
return render("search_removefromcoll.html", context)
else:
context['all_collections'] = Collection.objects
return render("search_entry.html", context)
def is_valid(cls, params):
"""Check if the exporter is valid for the given parameters."""
collid = getparam('coll', None, None, params)
if collid is None:
return False
return True
def write_collection(self, params):
params = dict(params)
id = unicode(params['id'][0])
del params['id']
coll = Collection.objects.get(id)
if coll is None:
return
if self.collid != id and self.collid not in coll.ancestors:
return
# Massive cut and paste follows
def items_of_type(type, cons, order, incsubs, reverse, hpp):
q = coll.items_from_search(type=type, incsubs=incsubs)
if order != 'collection':
q = q.order_by_multiple([])
order_key = order
if order.startswith('+'):
order_key, asc = order[1:], True
elif order.startswith('-'):
order_key, asc = order[1:], False
else:
order_key, asc = order, False
q = q.order_by(order_key, asc)
max_hpp = int(math.ceil(hpp * 1.25))
items = q[startrank:startrank + max_hpp]
if len(items) >= max_hpp:
items = items[:hpp]
return dict(coll_size=q.matches_estimated, items=items)
stash = {}
order = getparam('order', 'collection', stash, params)
incsubs = int(getparam('incsubs', '1', stash, params))
reverse = int(getparam('reverse', '0', stash, params))
startrank = int(getparam('startrank', '0', stash, params))
hpp = int(getparam('hpp', '100', stash, params))
tab = getparam('tab', 'records', stash, params)
# FIXME - do a faceted search to check which type tabs to show.
types_available, dates_available = self.types_in_collection(id)
allowed_ancestors = self.allowed_ancestors(coll)
tabs = self.tabs_for_collection(coll, types_available, dates_available,
allowed_ancestors)
context = dict(
stash = stash,
tab = tab,
tabs = tabs,
startrank = startrank,
coll = coll,
incsubs = incsubs,
)
pagination_params = dict(
hpp = hpp,
order = order,
reverse = reverse,
showfull = int(getparam('showfull', '1', stash, params)),
)
if tab == 'parents':
context['ancestor_objs'] = allowed_ancestors
if tab == 'records':
context.update(pagination_params)
context.update(items_of_type('record', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'images':
context.update(pagination_params)
context.update(items_of_type('image', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'video':
context.update(pagination_params)
context.update(items_of_type('video', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'audio':
context.update(pagination_params)
context.update(items_of_type('audio', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'media':
context.update(pagination_params)
context.update(items_of_type('media', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'calendar':
calstyle = getparam('calstyle', 'year', stash, params)
if calstyle not in ('year', 'month', 'day'):
calstyle = 'year'
datefield = getparam('datefield', 'date', stash, params)
startdate = getparam('startdate', '', stash, params)
year = getparam('year', None, None, params)
month = getparam('month', None, None, params)
day = getparam('day', None, None, params)
incsubs = True # FIXME - no UI to set at present
context.update(calendar_items(id, incsubs, calstyle, startdate,
year, month, day,
datefield))
stash['startdate'] = [context['startdate']]
if tab == 'children':
context['direct_records'] = items_of_type('record', lambda x: x, 'collection', 0, False, 10)
if tab.startswith('x'):
context['currpage'] = coll.page(tab[1:])
params['id'] = id
self.render('coll-view', (), params,
"export/html/coll-view.html", context)
def lookup_path_internal(self, name, args, kwargs):
#print name, args, kwargs
kwargs = get_args(kwargs)
if name == 'static':
static = u'/'.join(args)
if '..' in static.split('/') or static.startswith('/'):
print "error: invalid static %r" % static
return u'404.html'
self.gen_static.add(static)
return u'static/' + static
if name == 'record-view':
return u'record/%s.html' % kwargs['id']
if name == 'media':
path = kwargs['path']
self.gen_media.add(path)
return u'media%s' % path
if name == 'mediapreview':
path = kwargs['path']
self.gen_media.add(path)
htmlpath = path + '.html'
return u'mediaview%s' % htmlpath
if name == 'thumbnail':
path = kwargs['path']
width = kwargs['width']
width = kwargs.get('width')
height = kwargs.get('height')
self.gen_thumbnails.add((path, width, height))
fmt = get_format(path)
if path.endswith(fmt):
thumbpath = path
else:
thumbpath = path.rsplit('.', 1)[0] + '.' + fmt
if width is None:
return u'thumbnail/full/%s' % (thumbpath, )
else:
return u'thumbnail/%d/%d%s' % (width, height, thumbpath)
if name == 'record-gallery':
id = kwargs['id']
offset = kwargs.get('offset', None)
if offset is None:
show = kwargs['show']
offset = self.gallery_offset(id, show)
self.gen_gallery.add((id, offset))
return u'record/%s/gallery/%s.html' % (id, offset)
if name == 'coll-view':
collid = getparam('id', '', None, kwargs)
tab = getparam('tab', None, None, kwargs)
if tab is None:
types_available, dates_available = self.types_in_collection(collid)
coll = Collection.objects.get(collid)
if coll is not None:
allowed_ancestors = self.allowed_ancestors(coll)
tab = self.coll_maintab(coll, types_available, dates_available,
allowed_ancestors)
if tab is None:
tab = 'records'
startrank = int(getparam('startrank', '0', None, kwargs))
showfull = int(getparam('showfull', '0', None, kwargs))
incsubs = int(getparam('incsubs', '0', None, kwargs))
if tab not in ('records', 'images', 'video', 'audio', 'media'):
startrank = 0
showfull = 1
incsubs = 1
params = dict(id=collid, tab=tab, startrank=startrank,
incsubs=incsubs, showfull=showfull)
key = tuple(sorted((k, tupleify(v)) for (k, v) in params.iteritems()))
if key not in self.gen_colls:
#print "ADDING", key
#print '\n'.join(map(str, self.gen_colls))
self.gen_colls.add(key)
self.ungenerated_colls.add(key)
if showfull:
showfull = 'detail'
else:
showfull = 'list'
if incsubs:
incsubs = 'all'
else:
incsubs = 'coll'
if startrank:
startrank = 'from_%s' % startrank
else:
startrank = 'index'
return u'coll/%s/%s/%s/%s/%s.html' % (collid, tab, showfull, incsubs, startrank)
if name == 'search':
try:
del kwargs['act']
except KeyError: pass
if '*' in kwargs.get('collid', ()):
del kwargs['collid']
showfull = kwargs.get('showfull', ())
if isinstance(showfull, int):
pass
elif len(showfull) > 0 and int(showfull[0]) == 0:
showfull = 0
else:
showfull = 1
kwargs['showfull'] = [showfull]
startrank = kwargs.get('startrank', ())
if isinstance(startrank, int):
pass
elif len(startrank) > 0:
startrank = int(startrank[0])
else:
startrank = 0
kwargs['startrank'] = [startrank]
qs = kwargs.get('qs', ())
newqs = []
for qnum in qs:
# If there aren't corresponding q%df items skip this one.
qnum = int(qnum)
qf = kwargs.get('q%df' % qnum)
if qf is not None:
newqs.append(str(qnum))
kwargs['qs'] = tuple(newqs)
if not kwargs.get('ttypes'):
kwargs['ttypes'] = ('record', )
key = tuple(sorted((k, tupleify(v)) for (k, v) in kwargs.iteritems()))
searchid = self.gen_searches.get(key, None)
if searchid is None:
searchid = self.gen_search_id(key)
self.gen_searches[key] = searchid
self.search_ids[searchid] = key
self.ungenerated_searches.add(key)
return u'search/%s.html' % (searchid, )
if name == 'export-toppage':
return u'index.html'
print 'unhandled URL: ', repr(name), repr(args), repr(kwargs)
return u'404.html'
def view(self, id, **params):
coll = get_or_404(Collection, id)
def types_in_collection(collid):
q = SearchCollection.field.coll.is_or_is_descendant(collid)
q = q.calc_occur('!', '').check_at_least(-1)
q = q.calc_facet_count('date', result_limit=2)
q = q[:0]
return dict(q.info[0]['counts']), q.info[1]
def items_of_type(type, cons, order, incsubs, reverse, hpp):
q = coll.items_from_search(type=type, incsubs=incsubs)
if order != 'collection':
q = q.order_by_multiple([])
order_key = order
if order.startswith('+'):
order_key, asc = order[1:], True
elif order.startswith('-'):
order_key, asc = order[1:], False
else:
order_key, asc = order, False
q = q.order_by(order_key, asc)
max_hpp = int(math.ceil(hpp * 1.25))
items = q[startrank:startrank + max_hpp]
if len(items) >= max_hpp:
items = items[:hpp]
return dict(coll_size=q.matches_estimated, items=items)
stash = {}
order = getparam('order', 'collection', stash, params)
incsubs = int(getparam('incsubs', '1', stash, params))
reverse = int(getparam('reverse', '0', stash, params))
startrank = int(getparam('startrank', '0', stash, params))
hpp = int(getparam('hpp', '100', stash, params))
tab = getparam('tab', 'records', stash, params)
tabs = []
# FIXME - do a faceted search to check which type tabs to show.
types_available, dates_available = types_in_collection(id)
for page in coll.leading_tabs():
tabs.append("x" + page.id)
if coll.parents:
tabs.append('parents')
#if 'r' in types_available:
tabs.append("records")
if coll.children:
tabs.append('children')
if 'image' in types_available:
tabs.append("images")
if 'video' in types_available:
tabs.append("video")
if 'audio' in types_available:
tabs.append("audio")
if 'media' in types_available:
tabs.append("media")
if dates_available['values_seen'] >= 1:
tabs.append("calendar")
context = dict(
stash = stash,
tab = tab,
tabs = tabs,
startrank = startrank,
hpp = hpp,
coll = coll,
order = order,
incsubs = incsubs,
reverse = reverse,
showfull = int(getparam('showfull', '1', stash, params)),
)
if tab == 'records':
context.update(items_of_type('record', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'images':
context.update(items_of_type('image', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'video':
context.update(items_of_type('video', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'audio':
context.update(items_of_type('audio', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'media':
context.update(items_of_type('media', lambda x: x, order, incsubs, reverse, hpp))
if tab == 'calendar':
calstyle = getparam('calstyle', 'year', stash, params)
if calstyle not in ('year', 'month', 'day'):
calstyle = 'year'
datefield = getparam('datefield', 'date', stash, params)
startdate = getparam('startdate', '', stash, params)
year = getparam('year', None, None, params)
month = getparam('month', None, None, params)
day = getparam('day', None, None, params)
incsubs = True # FIXME - no UI to set at present
context.update(calendar_items(id, incsubs, calstyle, startdate,
year, month, day,
datefield))
stash['startdate'] = [context['startdate']]
if tab == 'children':
context['direct_records'] = items_of_type('record', lambda x: x, 'collection', 0, False, 10)
if tab.startswith('x'):
context['currpage'] = coll.page(tab[1:])
if params.get('lockto', None) == 'set':
set_lockto_collid(id)
elif params.get('lockto', None) == 'unset':
unset_lockto_collid()
return render("coll-view.html", context)
def param_from_form(key, required=True, params=None):
val = getparam(key, params=params)
if required and val is None:
raise ValidationError("Missing parameter %s" % key)
return val
def get_conflict_option(self, paramname, params):
value = getparam(paramname, 'newid', None, params)
if value not in ('overwrite', 'skip', 'newid', 'allnewid'):
value = 'newid'
return value
