def __init__(self, json_ld):
if isinstance(json_ld, dict):
self.json_ld = json_ld
self.ok = True
else:
self.ok = False
self.id = None # the search ID (url of the current results)
self.geotile_scope = '' # geo-tile applicable to all data
self.total_count = 0
self.start_num = 0
self.end_num = 0
self.items_per_page = 0
self.response_tile_zoom = 0
# is the item_type_limit is in effect ?
self.item_type_limited = False
self.subjects_link = False
self.filters = []
self.paging = {}
self.num_facets = []
self.date_facets = []
self.facets = []
self.geo_records = []
self.text_search = []
self.active_sort = {}
self.sort_options = []
self.project_layers = False
self.nav_items = settings.NAV_ITEMS
self.human_remains_ok = False # are we explicitly allowing display of human remains?
self.human_remains_flag = False # default to NO human remains flagged records in view
rp = RootPath()
self.base_url = rp.get_baseurl()
def pub_view(request):
""" Get publishing overview page """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/publishing',
'site_name': settings.CANONICAL_SITENAME,
'description': 'How to publish archaeological research data '\
'with Open Context',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/publishing.html')
context = {
'base_url': base_url,
'page_title': 'Open Context: About - Publishing',
'act_nav': 'about',
'og': open_graph,
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context, request))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def parse_json_option(self, json_option):
""" parses json option to populate
this object
"""
if 'id' in json_option:
self.id = json_option['id']
if 'json' in json_option:
self.json = json_option['json']
if 'label' in json_option:
self.label = json_option['label']
if 'count' in json_option:
self.count = json_option['count']
if 'slug' in json_option:
self.slug = json_option['slug']
if 'rdfs:isDefinedBy' in json_option:
if 'http://' in json_option['rdfs:isDefinedBy'] \
or 'https://' in json_option['rdfs:isDefinedBy']:
# assign this to a subheading
self.set_sub_heading(json_option['rdfs:isDefinedBy'])
rp = RootPath()
self.defined_by = rp.convert_local_url(
json_option['rdfs:isDefinedBy'])
self.dom_id = self.dom_id_prefix + '---' + str(self.slug)
# check to see if we should show this, based in if this is a related property
# and if self.item_type_limited is False
self.check_show_related_options()
def field_complex_descriptions(request, source_id):
""" Show HTML form to change group descriptive
properties together into groups of
complex descriptions
"""
if not request.user.is_superuser:
return HttpResponse('Unauthorized', status=401)
else:
rp = RootPath()
base_url = rp.get_baseurl()
ip = ImportProfile(source_id)
if ip.project_uuid is not False:
ip.get_fields()
if len(ip.fields) > 0:
ip.get_field_annotations()
ip.jsonify_field_annotations()
imnav = ImportNavigation()
ip.nav = imnav.set_nav('field-entity-relations',
ip.project_uuid, source_id)
template = loader.get_template(
'imports/field-entity-relations.html')
context = {
'ip': ip,
'base_url': base_url,
'user': request.user
}
return HttpResponse(template.render(context, request))
else:
redirect = '../../imports/field-types/' + source_id
return HttpResponseRedirect(redirect)
else:
raise Http404
def sponsors_view(request):
""" Get the page about sponsors """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/sponsors',
'site_name': settings.CANONICAL_SITENAME,
'description': 'Sources of financial support for '\
'Open Context and collaborative institutions providing '\
'complementary services',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/sponsors.html')
context = {
'base_url': base_url,
'page_title': 'Open Context: About - Intellectual Property',
'og': open_graph,
'act_nav': 'about',
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context, request))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def __init__(self):
rp = RootPath()
base_url = rp.get_baseurl()
self.href = base_url + '/about/estimate' # URL for this
self.estimate_id = False
self.user_name = ''
self.user_email = False
# self.user_phone = ''
self.project_name = ''
self.is_grad_student = False
self.duration = 0
self.count_spec_datasets = 0
self.count_tables = 0
self.count_images = 0
self.count_docs = 0
self.count_gis = 0
self.count_other = 0
self.comments = ''
self.license_uri = False
self.license_label = ''
self.license_note = ''
self.base_cost = 250 # minimum cost for publishing
self.max_cost = 7750 # maximum cost for an estimate
self.image_cost = 5
self.other_cost = 20
self.doc_cost = 15
self.gis_cost = 25
self.raw_cost = 0
self.errors = []
def index(request):
""" Get home page """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
old_view = False
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url,
'site_name': settings.CANONICAL_SITENAME,
'description': 'Home page for Open Context, an open access service for publishing, '\
'preserving, exploring and analyzing archaeological '\
'research data',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('index/view.html')
context = {
'base_url': base_url,
'old_view': old_view,
'page_title': 'Open Context: Publisher of Research Data',
'og': open_graph,
'act_nav': 'home',
'nav_items': settings.NAV_ITEMS
}
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
return HttpResponse(template.render(context, request))
else:
# client wanted a mimetype we don't support
return HttpResponse(template.render(context, request), status=415)
def field_types_more(request, source_id):
""" Show HTML form further classifying subject fields """
if not request.user.is_superuser:
return HttpResponse('Unauthorized', status=401)
else:
rp = RootPath()
base_url = rp.get_baseurl()
ip = ImportProfile(source_id)
if ip.project_uuid is not False:
ip.get_subject_type_fields()
imnav = ImportNavigation()
ip.nav = imnav.set_nav('field-types-more', ip.project_uuid,
source_id)
if len(ip.fields) > 0:
template = loader.get_template('imports/field-types-more.html')
context = {
'ip': ip,
'base_url': base_url,
'user': request.user
}
return HttpResponse(template.render(context, request))
else:
redirect = '../../imports/field-types/' + source_id
return HttpResponseRedirect(redirect)
else:
raise Http404
def __init__(self, id_href=True):
self.id = self.DOI # DOI for this
rp = RootPath()
base_url = rp.get_baseurl()
self.href = base_url + '/contexts/search.json' # URL for this
if id_href:
self.id = self.href
item_context_obj = ItemContext()
context = item_context_obj.context
self.geo_json_context = GeneralContext.GEO_JSON_CONTEXT_URI # link to geojson
context['opensearch'] = 'http://a9.com/-/spec/opensearch/1.1/'
context['totalResults'] = {'@id': 'opensearch:totalResults', '@type': 'xsd:integer'}
context['startIndex'] = {'@id': 'opensearch:startIndex', '@type': 'xsd:integer'}
context['itemsPerPage'] = {'@id': 'opensearch:itemsPerPage', '@type': 'xsd:integer'}
context['oc-api'] = 'http://opencontext.org/vocabularies/oc-api/'
context['oai-pmh'] = 'http://www.openarchives.org/OAI/2.0/'
context['rdfs:isDefinedBy'] = {'@type': '@id'}
context['first'] = {'@id': 'oc-api:first', '@type': '@id'}
context['previous'] = {'@id': 'oc-api:previous', '@type': '@id'}
context['next'] = {'@id': 'oc-api:next', '@type': '@id'}
context['last'] = {'@id': 'oc-api:last', '@type': '@id'}
context['first-json'] = {'@id': 'oc-api:first', '@type': '@id'}
context['previous-json'] = {'@id': 'oc-api:previous', '@type': '@id'}
context['next-json'] = {'@id': 'oc-api:next', '@type': '@id'}
context['last-json'] = {'@id': 'oc-api:last', '@type': '@id'}
context['count'] = {'@id': 'oc-api:count', '@type': 'xsd:integer'}
self.context = context
def estimate_view(request):
""" Get page with publication project cost estimation """
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/estimate',
'site_name': settings.CANONICAL_SITENAME,
'description': 'Estimate data publication and archiving '\
'costs with Open Context to help budget for '\
'grant data management plans',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/estimate.html')
context = {
'base_url': base_url,
'page_title': 'Open Context: About - Cost Estimate',
'og': open_graph,
'act_nav': 'about',
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context, request))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def __init__(self, uuid=None, request=None):
self.id_href = False # if True, use the local href as the Context's ID,
self.context_path = '/contexts/projects/' # path for the ID of the context resource
self.uuid = uuid
rp = RootPath()
self.base_url = rp.get_baseurl()
self.manifest = False
self.project_obj = False
self.edit_status = 0
self.edit_permitted = False
self.view_permitted = True
self.assertion_hashes = False
self.id = False
self.href = False
self.cannonical_href = False
self.json_ld = False
self.errors = []
self.pred_sql_dict_list = None
self.most_recent_date = None
self.refresh_cache = False
self.uuids_for_queries = None
if uuid is not None:
if uuid is False or uuid == '0' or uuid == 'open-context':
self.uuid = '0'
self.manifest = Manifest()
self.manifest.uuid = '0'
self.manifest.project_uuid = '0'
self.manifest.label = 'Open Context (General)'
self.manifest.item_type = 'projects'
else:
self.dereference_uuid_or_slug(uuid)
self.set_uri_urls(self.uuid)
if request is not None:
self.check_permissions(request)
def index(request):
""" Get the search context JSON-LD """
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
old_view = False
template = loader.get_template('index/view.html')
if 'test' in request.GET:
template = loader.get_template('index/view-initial-minimal.html')
old_view = True
context = RequestContext(
request, {
'base_url': base_url,
'old_view': old_view,
'page_title': 'Open Context: Publisher of Research Data',
'act_nav': 'home',
'nav_items': settings.NAV_ITEMS
})
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
return HttpResponse(template.render(context))
else:
# client wanted a mimetype we don't support
return HttpResponse(template.render(context), status=415)
def recipes_view(request):
""" Get page about recipes using the API """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/recipes',
'site_name': settings.CANONICAL_SITENAME,
'description': 'Specific guidance on the use of Open Context APIs '\
'(machine-readable data) to meet certain data '\
'management needs',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/recipes.html')
context = {
'base_url': base_url,
'page_title': 'Open Context: About - API Cookbook',
'og': open_graph,
'act_nav': 'about',
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def terms_view(request):
""" Get the page about Terms """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/terms',
'site_name': settings.CANONICAL_SITENAME,
'description': 'Terms and Conditions of Use, and '\
'Privacy Policies for Open Context',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/terms.html')
context = {
'base_url': base_url,
'page_title':
'Open Context: About - Terms of Use and Privacy Policies',
'og': open_graph,
'act_nav': 'about',
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def proxy_image_url_if_needed(image_url, primary_url=None, width=150):
"""Makes a proxy URL to an image file if needed"""
if not settings.MERRITT_IMAGE_PROXY:
return image_url
if not image_url:
return image_url
if not image_url.startswith('https://merritt.cdlib.org'):
return image_url
rp = RootPath()
base_url = rp.get_baseurl()
image_url = (base_url + '/entities/proxy/' + urllib.parse.quote(image_url))
if not primary_url or not primary_url.startswith(
'https://archive.org/download/'):
return image_url
archive_image_part = primary_url.split('https://archive.org/download/')[-1]
if not '/' in archive_image_part:
return image_url
archive_id_part = archive_image_part.split('/')[0]
image_url = (+ 'https://iiif.archivelab.org/iiif/' + archive_id_part +
'/full/{},/0/default.jpg'.format(width) + '#merritt-alt')
return image_url
def status(request, project_uuid):
""" View of the project status """
ocitem = OCitem()
ocitem.get_item(project_uuid)
ok_view = False
if ocitem.manifest is not False:
if ocitem.manifest.item_type == 'projects':
ok_view = True
if ok_view:
rp = RootPath()
base_url = rp.get_baseurl()
temp_item = TemplateItem(request)
temp_item.check_edit_permitted = True
temp_item.read_jsonld_dict(ocitem.json_ld)
if temp_item.edit_permitted:
p_o = ProjectOverview(project_uuid)
p_o.get_manifest_summary()
p_o.get_person_list()
# p_o. get_data_type_summary()
template = loader.get_template('edit/project-status.html')
context = {
'item': temp_item,
'super_user': request.user.is_superuser,
'icons': ItemBasicEdit.UI_ICONS,
'status': p_o,
'base_url': base_url,
'user': request.user
}
return HttpResponse(template.render(context, request))
else:
template = loader.get_template('edit/view401.html')
context = {'item': temp_item, 'base_url': base_url}
return HttpResponse(template.render(context, request), status=401)
else:
raise Http404
def check_list_view(request, uuid):
""" Displays the HTML item editing interface """
ocitem = OCitem()
ocitem.get_item(uuid)
if ocitem.manifest is not False:
if ocitem.manifest.item_type == 'projects':
rp = RootPath()
base_url = rp.get_baseurl()
temp_item = TemplateItem(request)
temp_item.check_edit_permitted = True
temp_item.read_jsonld_dict(ocitem.json_ld)
if temp_item.edit_permitted:
template = loader.get_template('edit/check-list.html')
context = RequestContext(
request, {
'item': temp_item,
'super_user': request.user.is_superuser,
'icons': ItemBasicEdit.UI_ICONS,
'base_url': base_url
})
return HttpResponse(template.render(context))
else:
template = loader.get_template('edit/view401.html')
context = RequestContext(request, {
'item': temp_item,
'base_url': base_url
})
return HttpResponse(template.render(context), status=401)
else:
raise Http404
else:
raise Http404
def html_view(request, uuid):
ocitem = OCitem()
ocitem.get_item(uuid, True)
if (ocitem.manifest is not False):
rp = RootPath()
base_url = rp.get_baseurl()
temp_item = TemplateItem()
temp_item.read_jsonld_dict(ocitem.json_ld)
template = loader.get_template('projects/view.html')
req_neg = RequestNegotiation('text/html')
req_neg.supported_types = ['application/json', 'application/ld+json']
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
if 'json' in req_neg.use_response_type:
# content negotiation requested JSON or JSON-LD
return HttpResponse(json.dumps(ocitem.json_ld,
ensure_ascii=False,
indent=4),
content_type=req_neg.use_response_type +
"; charset=utf8")
else:
context = RequestContext(request, {
'item': temp_item,
'base_url': base_url
})
return HttpResponse(template.render(context))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message,
content_type=req_neg.use_response_type +
"; charset=utf8",
status=415)
else:
raise Http404
def bibliography_view(request):
""" Get page about bibliography / publications """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/bibliography',
'site_name': settings.CANONICAL_SITENAME,
'description': 'Publications related to Open Context and its '\
'contributions to research data management, '\
'archaeological ethics, scholarly communications, and '\
'professional practice',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/bibliography.html')
context = {
'base_url': base_url,
'page_title': 'Open Context: About - Bibliography',
'og': open_graph,
'act_nav': 'about',
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context, request))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def ip_view(request):
""" Get page about IP policies """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/intellectual-property',
'site_name': settings.CANONICAL_SITENAME,
'description': 'Intellectual property policies for Open Context and '\
'ethical guidance for contributors and users of '\
'archaeological research data',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/intellectual-property.html')
context = {
'base_url': base_url,
'page_title': 'Open Context: About - Intellectual Property',
'og': open_graph,
'act_nav': 'about',
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def services_view(request):
""" Get page documenting the API """
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
req_neg = RequestNegotiation('text/html')
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if req_neg.supported:
# requester wanted a mimetype we DO support
open_graph = {
'twitter_site': settings.TWITTER_SITE,
'type': 'website',
'url': base_url + '/about/technology',
'site_name': settings.CANONICAL_SITENAME,
'description': 'Overview of the APIs (machine-readable data) '\
'offered by Open Context to promote '\
'interoperability and new uses of data',
'image': base_url + '/static/oc/images/index/oc-blue-square-logo.png',
'video': False
}
template = loader.get_template('about/services.html')
context = {
'base_url': base_url,
'page_title': 'Open Context: About - Web Services and APIs',
'og': open_graph,
'act_nav': 'about',
'nav_items': settings.NAV_ITEMS
}
return HttpResponse(template.render(context))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message, status=415)
def html_view(request, spatial_context=None):
rp = RootPath()
base_url = rp.get_baseurl()
rd = RequestDict()
request_dict_json = rd.make_request_dict_json(request,
spatial_context)
url = request.get_full_path()
if 'http://' not in url \
and 'https://' not in url:
url = base_url + url
if '?' in url:
json_url = url.replace('?', '.json?')
else:
json_url = url + '.json'
solr_s = SolrSearch()
if solr_s.solr is not False:
response = solr_s.search_solr(request_dict_json)
m_json_ld = MakeJsonLd(request_dict_json)
# share entities already looked up. Saves database queries
m_json_ld.entities = solr_s.entities
m_json_ld.request_full_path = request.get_full_path()
m_json_ld.spatial_context = spatial_context
json_ld = m_json_ld.convert_solr_json(response.raw_content)
req_neg = RequestNegotiation('text/html')
req_neg.supported_types = ['application/json',
'application/ld+json']
if 'HTTP_ACCEPT' in request.META:
req_neg.check_request_support(request.META['HTTP_ACCEPT'])
if 'json' in req_neg.use_response_type:
# content negotiation requested JSON or JSON-LD
recon_obj = Reconciliation()
json_ld = recon_obj.process(request.GET,
json_ld)
return HttpResponse(json.dumps(json_ld,
ensure_ascii=False, indent=4),
content_type=req_neg.use_response_type + "; charset=utf8")
else:
# now make the JSON-LD into an object suitable for HTML templating
st = SearchTemplate(json_ld)
st.process_json_ld()
template = loader.get_template('sets/view.html')
context = RequestContext(request,
{'st': st,
'url': url,
'json_url': json_url,
'base_url': base_url})
if req_neg.supported:
return HttpResponse(template.render(context))
else:
# client wanted a mimetype we don't support
return HttpResponse(req_neg.error_message,
content_type=req_neg.use_response_type + "; charset=utf8",
status=415)
else:
template = loader.get_template('500.html')
context = RequestContext(request,
{'error': 'Solr Connection Problem'})
return HttpResponse(template.render(context), status=503)
def index(request):
""" redirects requests from the media index
to the media-search view
"""
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
new_url = base_url + '/search/?type=documents'
return redirect(new_url, permanent=True)
def index(request):
""" redirects requests from the projects index
to the project-search view
"""
request = RequestNegotiation().anonymize_request(request)
rp = RootPath()
base_url = rp.get_baseurl()
new_url = base_url + '/projects-search/'
return redirect(new_url, permanent=True)
def __init__(self, request_dict_json=False):
self.uuid = False
self.uri = False # cannonical uri for the item
self.href = False # link to the item in the current deployment
self.cite_uri = False # stable / persistent uri
self.label = False
self.item_type = False
self.updated = False
self.published = False
self.project_href = False # link to the project in current deployment
self.project_uri = False # cannonical uri for the project
self.project_label = False
self.context_href = False # link to parent context in current deployment
self.context_uri = False # link to parent context cannonical uri
self.context_label = False
self.category = False
self.latitude = False
self.longitude = False
self.geojson = False
self.early_date = False
self.late_date = False
self.human_remains_flagged = False # flagged as relating to human remains
self.thumbnail_href = False
self.thumbnail_uri = False
self.thumbnail_scr = False
self.preview_scr = False
self.fullfile_scr = False
self.snippet = False
self.cite_uri = False # stable identifier as an HTTP uri
self.other_attributes = False # other attributes to the record
# flatten list of an attribute values to single value
self.flatten_rec_attributes = False
# A list of (non-standard) attributes to include in a record
self.rec_attributes = []
self.attribute_hierarchies = {}
self.base_url = settings.CANONICAL_HOST
rp = RootPath()
self.base_url = rp.get_baseurl()
self.m_cache = MemoryCache() # memory caching object
self.s_cache = SearchGenerationCache(
) # supplemental caching object, specific for searching
self.request_dict_json = request_dict_json
if request_dict_json is not False:
self.request_dict = json.loads(request_dict_json)
else:
self.request_dict = False
self.add_attribute_uris = False
if self.request_dict and self.request_dict.get('add-attribute-uris'):
self.add_attribute_uris = True
self.highlighting = False
self.recursive_count = 0
self.min_date = False
self.max_date = False
self.thumbnail_data = {}
self.media_file_data = {}
self.string_attrib_data = {}
def __init__(self,
request_dict=None,
current_filters_url=None,
base_search_url='/search/'):
rp = RootPath()
self.base_url = rp.get_baseurl()
self.base_search_url = base_search_url
self.request_dict = copy.deepcopy(request_dict)
self.current_filters_url = current_filters_url
self.doc_formats = configs.REQUEST_URL_FORMAT_EXTENTIONS
def __init__(self, json_ld):
rp = RootPath()
self.base_url = rp.get_baseurl()
if isinstance(json_ld, dict):
self.json_ld = json_ld
self.ok = True
else:
self.ok = False
self.raw_records = []
self.records = []
def __init__(self):
self.entries_per_page = self.DEFAULT_ENTRIES_PER_PAGE
self.page = self.DEFAULT_PAGE
self.count = 0
self.updated = False
self.last_page = False
rp = RootPath()
self.base_url = rp.get_baseurl()
self.projects_list = []
self.limit_item_types = []
def __init__(self):
self.item_gen_cache = ItemGenerationCache()
rp = RootPath()
self.base_url = rp.get_baseurl()
self.class_uri_list = [] # uris of item classes used in this item
self.manifest_obj_dict = {} # manifest objects, in a dict with uuid as key
self.proj_context_json_ld = {} # general project context JSON-LD, with @graph of predicates, types
self.stable_id_predicate = False # predicate to use to add a stable ID to an entity
self.stable_id_prefix_limit = False # limit adding stable ID to the following URI prefix
self.predicate_uri_as_stable_id = False # add the predicate full URI as a stable id with the stable_id_predicate
def __init__(self, cannonical_uris=False):
self.cannonical_uris = cannonical_uris
self.cache_use = CacheUtilities()
dc_terms_obj = DCterms()
self.dc_metadata_preds = dc_terms_obj.get_dc_terms_list()
rp = RootPath()
if self.cannonical_uris:
self.base_url = rp.cannonical_host
else:
self.base_url = rp.get_baseurl()
