def get_brief_view(work_key):
work_template = template.loader.get_template('work-brief-view.html')
work = {
'url':
'/apps/discovery/Manuscript/{0}'.format(work_key.split(":")[-1])
}
instance_key = REDIS_DATASTORE.hget(work_key, 'hasInstance')
title_key = REDIS_DATASTORE.hget(work_key, 'title')
work['title'] = REDIS_DATASTORE.hget(title_key, 'label')
work['pdf_url'] = REDIS_DATASTORE.hget(instance_key, 'schema:contentUrl')
work['topics'] = []
topic_keys = []
if REDIS_DATASTORE.hexists(work_key, 'subject'):
topic_key = REDIS_DATASTORE.hget(work_key, 'subject')
topic_keys.append(topic_key)
else:
topic_keys.extend(
list(REDIS_DATASTORE.smembers('{0}:subject'.format(work_key))))
for topic_key in topic_keys:
work['topics'].append({
'label':
REDIS_DATASTORE.hget(topic_key, 'label'),
'url':
'/apps/discovery/Topic/{0}'.format(topic_key.split(":")[-1])
})
return mark_safe(work_template.render(template.Context({'work': work})))
def display_brief(work):
"Returns CC version of a Brief summary based on White While DL design"
work_template = template.loader.get_template(
'cc-brief.html')
title_entity = REDIS_DATASTORE.hget(work.title, 'label')
if REDIS_DATASTORE.hexists(work.redis_key, "rda:isCreatedBy"):
creators_keys = [REDIS_DATASTORE.hget(work.redis_key,
"rda:isCreatedBy"),]
else:
creators_keys = list(REDIS_DATASTORE.smembers(
"{0}:rda:isCreatedBy".format(work.redis_key)))
creators = []
for redis_key in creators_keys[:4]:
creator = {'id': redis_key.split(":")[-1]}
given_name = REDIS_DATASTORE.hget(redis_key, 'schema:givenName')
if given_name is not None:
creator['givenName'] = unicode(given_name, errors='ignore')
family_name = REDIS_DATASTORE.hget(redis_key, 'schema:familyName')
if family_name is not None:
creator['familyName'] = unicode(family_name, errors='ignore')
creator['name'] = unicode(REDIS_DATASTORE.hget(redis_key,
'rda:preferredNameForThePerson'),
errors='ignore')
creators.append(creator)
context = template.Context({'creators': creators,
'title': title_entity,
'work': work}
)
return mark_safe(work_template.render(context))
def __get_featured_instances__(featured_instances=FEATURED_INSTANCES):
"Helper function iterates through featured instances returns list"
output = []
for instance_key in featured_instances:
cover_art_key = None
instance_link = '/apps/discovery/Instance/{0}'.format(
instance_key.split(":")[-1])
for annotation_key in REDIS_DATASTORE.smembers(
'{0}:hasAnnotation'.format(instance_key)):
if annotation_key.startswith('bf:CoverArt'):
cover_art_key = annotation_key
work_key = REDIS_DATASTORE.hget(instance_key,
'instanceOf')
cover_id = cover_art_key.split(":")[-1]
cover_url = '/apps/discovery/CoverArt/{0}-'.format(cover_id)
if REDIS_DATASTORE.hexists(cover_art_key, 'annotationBody'):
cover_url += "body.jpg"
else:
cover_url += 'thumbnail.jpg'
output.append(
{'cover': cover_url,
'title': REDIS_DATASTORE.hget(
'{0}:title'.format(work_key),
'rda:preferredTitleForTheWork'),
'instance': instance_link})
return output
def get_featured_instances(num_items=5):
"""
Returns Creative Works that display as a listing of
BIBFRAME Instances, will display CoverArt if available
:param num_items: Number of featured items
"""
featured_instances = []
featured_keys = REDIS_DATASTORE.smembers('prospector:featured')
for key in featured_keys:
info = {'redis_key': key}
featured_instances.append(info)
featured_items_template = template.loader.get_template(
'discovery/carl-featured-instances.html')
return mark_safe(featured_items_template.render(template.Context({
'instances': featured_instances})))
def author_of(person):
"Returns div with a list of Works that the person is an author of"
author_role_key = "{0}:resourceRole:aut".format(person.redis_key)
if not REDIS_DATASTORE.exists(author_role_key):
return mark_safe('')
author_html = """<div class="alert alert-info alert-block">
<h3>Author's Creative Works</h3><ul>"""
for work_key in REDIS_DATASTORE.smembers(author_role_key):
work_info = work_key.split(":")
title_key = REDIS_DATASTORE.hget(work_key, 'title')
title = REDIS_DATASTORE.hget(title_key, 'label')
author_html += """<li>{0} <em><a href="/apps/discovery/{0}/{1}">{2}</a></li></em>
""".format(work_info[1],
work_info[-1],
title)
author_html += "</ul></div>"
return mark_safe(author_html)
def get_subjects(creative_work):
work_key = creative_work.redis_key
output = ""
subject_work_key = "{0}:subject".format(work_key)
if REDIS_DATASTORE.exists(subject_work_key):
for topic_key in REDIS_DATASTORE.smembers(subject_work_key):
topic_id = topic_key.split(":")[-1]
label = REDIS_DATASTORE.hget(topic_key, 'label')
output += """<li><a href="/apps/discovery/Topic/{0}">{1}</a>
</li>
""".format(topic_id, label)
else:
topic_key = REDIS_DATASTORE.hget(work_key, 'subject')
topic_id = topic_key.split(":")[-1]
label = REDIS_DATASTORE.hget(topic_key, 'label')
output += """<li><a href="/apps/discovery/Topic/{0}">{1}</a></li>
""".format(topic_id, label)
return mark_safe(output)
def get_subjects(creative_work):
work_key = creative_work.redis_key
output = ""
subject_work_key = "{0}:subject".format(work_key)
if REDIS_DATASTORE.exists(subject_work_key):
for topic_key in REDIS_DATASTORE.smembers(
subject_work_key):
topic_id = topic_key.split(":")[-1]
label = REDIS_DATASTORE.hget(topic_key, 'label')
output += """<li><a href="/apps/discovery/Topic/{0}">{1}</a>
</li>
""".format(topic_id, label)
else:
topic_key = REDIS_DATASTORE.hget(work_key, 'subject')
topic_id = topic_key.split(":")[-1]
label = REDIS_DATASTORE.hget(topic_key, 'label')
output += """<li><a href="/apps/discovery/Topic/{0}">{1}</a></li>
""".format(topic_id, label)
return mark_safe(output)
def display_instances(work):
"Generates a display of all of the instances for a work"
work_instances_template = template.loader.get_template(
'cc-work-instances.html')
instances = []
instance_keys = list(REDIS_DATASTORE.smembers(
"{0}:hasInstance".format(work.redis_key)))
if len(instance_keys) < 1:
instance_key = REDIS_DATASTORE.hget(work.redis_key,
'hasInstance')
if instance_key is not None:
instance_keys.append(instance_key)
for instance_key in instance_keys:
instances.append(
Instance(redis_key=instance_key,
redis_datastore=REDIS_DATASTORE))
context = template.Context({'instances': instances})
return mark_safe(work_instances_template.render(context))
def person_json_ld(request, redis_id):
"""
Person JSON-LD view for the discovery app
:param request: HTTP Request
:param redis_id": Redis integer for the Person
"""
redis_key = "bibframe:Person:{0}".format(redis_id)
if REDIS_DATASTORE.exists(redis_key):
json_linked_data = get_json_linked_data(redis_datastore=REDIS_DATASTORE,
redis_key=redis_key)
for work_key in list(REDIS_DATASTORE.smembers("{0}:rda:isCreatorPersonOf")):
work_url = "http://{0}/apps/discovery/Work/{1}".format(request.get_host(),
work_key.split(":")[-1])
if json_linked_data.has_key('rda:isCreatorPersonOf'):
json_linked_data['rda:isCreatorPersonOf'].append(work_url)
else:
json_linked_data['rda:isCreatorPersonOf'] = [work_url,]
return json_linked_data
def get_creators(bibframe_entity):
output = '<ul class="icons-ul">'
if type(bibframe_entity) == Instance:
redis_key = bibframe_entity.attributes.get('instanceOf')
else:
redis_key = bibframe_entity.redis_key
if REDIS_DATASTORE.hexists(redis_key,"rda:isCreatedBy"):
creators = [REDIS_DATASTORE.hget(redis_key,"rda:isCreatedBy"),]
else:
creators = list(REDIS_DATASTORE.smembers("{0}:rda:isCreatedBy".format(redis_key)))
for i, key in enumerate(creators):
creator_id = key.split(":")[-1]
output += """<li><a href="/apps/discovery/Person/{0}">
<i class="icon-li icon-user"></i> {1}</a></li>""".format(
key.split(":")[-1],
REDIS_DATASTORE.hget(key,
'rda:preferredNameForThePerson'))
output += "</ul>"
return mark_safe(output)
def get_brief_view(work_key):
work_template = template.loader.get_template('work-brief-view.html')
work = {
'url': '/apps/discovery/Manuscript/{0}'.format(work_key.split(":")[-1])}
instance_key = REDIS_DATASTORE.hget(work_key, 'hasInstance')
title_key = REDIS_DATASTORE.hget(work_key, 'title')
work['title'] = REDIS_DATASTORE.hget(title_key, 'label')
work['pdf_url'] = REDIS_DATASTORE.hget(instance_key, 'schema:contentUrl')
work['topics'] = []
topic_keys = []
if REDIS_DATASTORE.hexists(work_key, 'subject'):
topic_key = REDIS_DATASTORE.hget(work_key, 'subject')
topic_keys.append(topic_key)
else:
topic_keys.extend(list(REDIS_DATASTORE.smembers(
'{0}:subject'.format(work_key))))
for topic_key in topic_keys:
work['topics'].append(
{'label': REDIS_DATASTORE.hget(topic_key, 'label'),
'url': '/apps/discovery/Topic/{0}'.format(
topic_key.split(":")[-1])})
return mark_safe(
work_template.render(
template.Context({'work': work})))
def bibframe_router(request,
entity_name,
redis_id):
"""View routes based on the Bibframe class and Redis id
Parameters:
entity_name -- Bibframe class anem
redis_id -- Redis integer for the Bibframe entity
"""
bibframe_key = "bf:{0}:{1}".format(entity_name,
redis_id)
if not REDIS_DATASTORE.exists(bibframe_key):
bibframe_key = "bf:{0}:{1}".format(entity_name.title(),
redis_id)
if not REDIS_DATASTORE.exists(bibframe_key):
raise Http404
if CREATIVE_WORK_CLASSES.count(entity_name) > 0:
cw_class = getattr(bibframe.models,
entity_name)
if cw_class is None:
cw_class = getattr(bibframe.models,
entity_name.title())
creative_work = cw_class(
redis_datastore=REDIS_DATASTORE,
redis_key=bibframe_key)
return render(request,
'discovery/work.html',
{'app': APP,
'creative_work':creative_work,
'feedback_form':FeedbackForm({'subject':'Discovery App Creative Work'}),
'feedback_context':request.get_full_path(),
'institution': INSTITUTION,
'search_form': SearchForm(),
'user':None})
elif entity_name == 'Holding':
holding = Holding(
redis_datastore=REDIS_DATASTORE,
redis_key=bibframe_key)
return render(request,
'discovery/holding.html',
{'app': APP,
'feedback_form':FeedbackForm(
{'subject':'Discovery App Holding'}),
'feedback_context':request.get_full_path(),
'holding': holding,
'holding_json': get_json_linked_data(
redis_datastore=REDIS_DATASTORE,
redis_key=bibframe_key),
'institution': INSTITUTION,
'search_form': SearchForm(),
'user': request.user})
elif entity_name == 'Instance':
instance = Instance(
redis_datastore=REDIS_DATASTORE,
redis_key=bibframe_key)
return render(request,
'discovery/instance.html',
{'app': APP,
'feedback_form':FeedbackForm({'subject':'Discovery App Instance'}),
'feedback_context':request.get_full_path(),
'instance':instance,
'institution': INSTITUTION,
'search_form': SearchForm(),
'user':None})
elif entity_name == 'Organization':
organization = bibframe.models.Organization(
redis_datastore=REDIS_DATASTORE,
redis_key=bibframe_key)
return render(request,
'discovery/organization.html',
{'app': APP,
'feedback_form':FeedbackForm({'subject':'Discovery App Organization'}),
'feedback_context':request.get_full_path(),
'organization': organization,
'search_form': SearchForm(),
'user': None})
elif entity_name == 'Person':
person = bibframe.models.Person(
redis_datastore=REDIS_DATASTORE,
redis_key=bibframe_key)
return render(request,
'discovery/person.html',
{'app': APP,
'feedback_form':FeedbackForm({'subject':'Discovery App Organization'}),
'feedback_context':request.get_full_path(),
'person': person,
'search_form': SearchForm(),
'user': None})
elif entity_name == 'Topic':
def sort_func(work_key):
title_key = REDIS_DATASTORE.hget(work_key, 'title')
return REDIS_DATASTORE.hget(title_key, 'label')
topic = bibframe.models.Topic(
redis_datastore=REDIS_DATASTORE,
redis_key=bibframe_key)
work_keys = list(REDIS_DATASTORE.smembers('{0}:works'.format(bibframe_key)))
work_keys.sort(key=lambda x: sort_func(x))
return render(request,
'discovery/topic.html',
{'app': APP,
'feedback_form':FeedbackForm({'subject':'Discovery App Organization'}),
'feedback_context':request.get_full_path(),
'topic': topic,
'works': work_keys,
'search_form': SearchForm(),
'user': None})
return HttpResponse("{0} exits {1}".format(
bibframe_key,
REDIS_DATASTORE.exists(bibframe_key)))
