def create_resource_url(request):
context = RequestContext(request, {})
template = loader.get_template('create_resource_url.html')
if request.method == 'GET':
form = UserResourceURLForm()
elif request.method == 'POST':
form = UserResourceURLForm(request.POST)
if form.is_valid():
url = form.cleaned_data.get('url')
exists, headers = _ping_resource(url)
if exists:
content, created = Resource.objects.get_or_create(
**{
'location': url,
'content_resource': True,
'defaults': {
'name': url,
'content_type': headers.get('Content-Type', None),
'created_by': request.user,
}
})
if created:
operations.add_creation_metadata(content, request.user)
return HttpResponseRedirect(
reverse('create-resource-details', args=(content.id, )))
else:
form.add_error('url', u'Could not access a resource at that' \
+ u' location. Please check the URL and' \
+ u' try again.')
context.update({'form': form})
return HttpResponse(template.render(context))
def create_resource_file(request):
context = RequestContext(request, {})
template = loader.get_template('create_resource_file.html')
if request.method == 'GET':
form = UserResourceFileForm()
elif request.method == 'POST':
form = UserResourceFileForm(request.POST, request.FILES)
if form.is_valid():
uploaded_file = request.FILES['upload_file']
content = Resource.objects.create(
**{
'content_type': uploaded_file.content_type,
'content_resource': True,
'name': uploaded_file._name,
'created_by': request.user,
})
operations.add_creation_metadata(content, request.user)
# The file upload handler needs the Resource to have an ID first,
# so we add the file after creation.
content.file = uploaded_file
content.save()
return HttpResponseRedirect(
reverse('create-resource-details', args=(content.id, )))
context.update({'form': form})
return HttpResponse(template.render(context))
def to_resource(datum):
uri = datum.get('uri')
if 'jstor' in uri:
collection = jhb
elif 'handle' in uri:
collection = embryo
with transaction.atomic():
container = ResourceContainer.objects.create(created_by=user,
part_of=collection)
master = Resource.objects.create(name=datum['name'],
uri=datum['uri'],
created_by=user,
container=container)
container.primary = master
container.save()
original_location = datum.get('original')
if original_location:
external = Resource.objects.create(
container=container,
name=datum['name'],
content_resource=True,
location=original_location,
is_external=True,
created_by=user,
)
ContentRelation.objects.create(
for_resource=master,
container=container,
content_resource=external,
created_by=user,
)
base_path = '/home/amphora/vogon-export'
fname = datum.get('file')
fpath = os.path.join(base_path, fname)
content = Resource.objects.create(
**{
'content_type': mimetypes.guess_type(fpath)[0],
'content_resource': True,
'name': fname,
'created_by': user,
'container': container,
})
operations.add_creation_metadata(content, user)
with open(fpath, 'r') as f:
uploaded_file = File(f)
# The file upload handler needs the Resource to have an ID first,
# so we add the file after creation.
content.file = uploaded_file
content.save()
content_relation = ContentRelation.objects.create(
**{
'for_resource': master,
'content_resource': content,
'content_type': content.content_type,
'container': container,
})
return master
def set_giles_upload_collection(request, upload_id):
"""
User can add a resource created from a :class:`.GilesUpload` to a
:class:`.Collection`\.
"""
upload = get_object_or_404(GilesUpload, upload_id=upload_id)
if not upload.state == GilesUpload.DONE:
raise RuntimeError('Not ready')
if not upload.resource:
raise RuntimeError('No resource')
if upload.created_by != request.user:
raise RuntimeError('WTF') # TODO: say something more informative.
context = {
'upload': upload,
}
if request.method == 'GET':
form = ChooseCollectionForm()
# User can only add resources to collections for which they have ADD
# privileges.
qs = auth.apply_filter(CollectionAuthorization.ADD, request.user,
form.fields['collection'].queryset)
form.fields['collection'].queryset = qs
elif request.method == 'POST':
form = ChooseCollectionForm(request.POST)
# User can only add resources to collections for which they have ADD
# privileges.
qs = auth.apply_filter(CollectionAuthorization.ADD, request.user,
form.fields['collection'].queryset)
form.fields['collection'].queryset = qs
if form.is_valid():
collection = form.cleaned_data.get('collection', None)
name = form.cleaned_data.get('name', None)
# The user has the option to create a new Collection by leaving the
# collection field blank and providing a name.
if collection is None and name is not None:
collection = Collection.objects.create(
**{
'created_by_id': request.user.id,
'name': name,
})
operations.add_creation_metadata(collection, request.user)
form.fields['collection'].initial = collection.id
form.fields['name'].widget.attrs['disabled'] = True
upload.resource.container.part_of = collection
upload.resource.container.save()
context.update({'form': form})
return render(request, 'create_process_giles_upload.html', context)
def create_from_file(path, collection, user, resource_data, creation_message):
name = os.path.split(path)[-1]
if collection.resourcecontainer_set.filter(primary__name=name).count() > 0:
return
container = ResourceContainer.objects.create(created_by=user,
part_of=collection)
content = Resource.objects.create(
**{
'content_type': mimetypes.guess_type(path)[0],
'content_resource': True,
'name': name,
'created_by': user,
'container': container,
})
operations.add_creation_metadata(content, user)
with open(path, 'r') as f:
uploaded_file = File(f)
# The file upload handler needs the Resource to have an ID first,
# so we add the file after creation.
content.file = uploaded_file
content.save()
resource_data['created_by'] = user
resource_data['container'] = content.container
resource = Resource.objects.create(**resource_data)
content.container.primary = resource
content.container.save()
operations.add_creation_metadata(resource, user)
Relation.objects.create(
**{
'source':
resource,
'predicate':
__provenance__,
'target':
Value.objects.create(
**{
'_value': jsonpickle.encode(creation_message),
'container': resource.container,
}),
'container':
resource.container,
})
content_relation = ContentRelation.objects.create(
**{
'for_resource': resource,
'content_resource': content,
'content_type': content.content_type,
'container': content.container,
})
resource.container = content.container
resource.save()
return resource.container
def create_resource_details(request, content_id):
content_resource = get_object_or_404(Resource, pk=content_id)
context = RequestContext(request, {})
if request.method == 'GET':
form = UserResourceForm(
initial={
'name': content_resource.name,
'uri': content_resource.location,
'public':
True, # If the resource is already online, it's public.
})
form.fields['collection'].queryset = authorization.apply_filter(
*(request.user, 'change_collection',
form.fields['collection'].queryset))
# It wouldn't mean much for the user to indicate that the resource was
# non-public, given that we are accessing it over a public connection.
# form.fields['public'].widget.attrs.update({'disabled': True})
elif request.method == 'POST':
form = UserResourceForm(request.POST)
if form.is_valid():
resource_data = copy.copy(form.cleaned_data)
resource_data['entity_type'] = resource_data.pop(
'resource_type', None)
collection = resource_data.pop('collection', None)
resource_data['created_by'] = request.user
resource = Resource.objects.create(**resource_data)
operations.add_creation_metadata(resource, request.user)
content_relation = ContentRelation.objects.create(
**{
'for_resource': resource,
'content_resource': content_resource,
'content_type': content_resource.content_type,
})
if collection:
collection.resources.add(resource)
collection.save()
return HttpResponseRedirect(
reverse('resource', args=(resource.id, )))
context.update({
'form': form,
'content_resource': content_resource,
})
template = loader.get_template('create_resource_details.html')
return HttpResponse(template.render(context))
def process_giles_upload(request, session_id):
"""
"""
session = get_object_or_404(GilesSession, pk=session_id)
context = RequestContext(request, {
'session': session,
})
if request.method == 'GET':
form = ChooseCollectionForm()
form.fields['collection'].queryset = form.fields[
'collection'].queryset.filter(created_by_id=request.user.id)
if session.collection:
collection_id = session.collection
else:
collection_id = request.GET.get('collection_id', None)
if collection_id:
form.fields['collection'].initial = collection_id
context.update({'collection_id': collection_id})
elif request.method == 'POST':
form = ChooseCollectionForm(request.POST)
form.fields['collection'].queryset = form.fields[
'collection'].queryset.filter(created_by_id=request.user.id)
if form.is_valid():
collection = form.cleaned_data.get('collection', None)
name = form.cleaned_data.get('name', None)
if not collection and name:
collection = Collection.objects.create(
**{
'created_by_id': request.user.id,
'name': name,
})
operations.add_creation_metadata(collection, request.user)
session.collection = collection
session.save()
form.fields['collection'].initial = collection.id
form.fields['name'].widget.attrs['disabled'] = True
context.update({'form': form})
template = loader.get_template('create_process_giles_upload.html')
return HttpResponse(template.render(context))
def _create_resource_file(request, uploaded_file, upload_interface):
container = ResourceContainer.objects.create(created_by=request.user)
content = Resource.objects.create(
**{
'content_type': uploaded_file.content_type,
'content_resource': True,
'name': uploaded_file._name,
'created_by': request.user,
'created_through': upload_interface,
'container': container,
})
collection = request.GET.get('collection')
if collection:
container.part_of_id = collection
container.save()
operations.add_creation_metadata(content, request.user)
# The file upload handler needs the Resource to have an ID first,
# so we add the file after creation.
content.file = uploaded_file
content.save()
return content
def _create_resource_details(request, content_resource, resource_data,
upload_interface):
resource_data['entity_type'] = resource_data.pop('resource_type')
collection = resource_data.pop('collection', None)
if not content_resource.container:
content_resource.container = ResourceContainer.objects.create(
created_by=request.user, part_of=collection)
content_resource.save()
else:
content_resource.container.part_of = collection
resource_data['created_by'] = request.user
resource_data['created_through'] = upload_interface
resource_data['container'] = content_resource.container
resource = Resource.objects.create(**resource_data)
content_resource.container.primary = resource
content_resource.container.save()
operations.add_creation_metadata(resource, request.user)
content_relation = ContentRelation.objects.create(
**{
'for_resource': resource,
'content_resource': content_resource,
'content_type': content_resource.content_type,
'container': content_resource.container,
})
resource.container = content_resource.container
resource.save()
if resource_data.get('public'):
ResourceAuthorization.objects.create(
granted_by=request.user,
granted_to=None,
action=ResourceAuthorization.VIEW,
policy=ResourceAuthorization.ALLOW,
for_resource=resource.container)
return resource
def handle_bulk(self,
file_path,
form_data,
file_name,
job=None,
ingester='cookies.accession.zotero.ZoteroIngest'):
"""
Process resource data in a RDF document.
Parameters
----------
file_path : str
Local path to a RDF document, or a ZIP file containing a Zotero RDF
export (with files).
form_data : dict
Valid data from a :class:`cookies.forms.BulkResourceForm`\.
file_name : str
Name of the target file at ``file_path``\.
job : :class:`.UserJob`
Used to update progress.
"""
if job:
job.result_id = self.request.id
job.save()
logger.debug('handle bulk')
creator = form_data.pop('created_by')
# The user can either add these new records to an existing collection, or
# create a new one.
collection = form_data.pop('collection', None)
collection_name = form_data.pop('name', None)
if not collection:
collection = Collection.objects.create(**{
'name': collection_name,
'created_by': creator,
})
operations.add_creation_metadata(collection, creator)
# User can indicate a default Type to assign to each new Resource.
default_type = form_data.pop('default_type', None)
ingester = IngesterFactory().get(ingester)(file_path)
ingester.Resource = authorization.apply_filter(creator, 'change_resource',
ingester.Resource)
ingester.Collection = authorization.apply_filter(creator,
'change_collection',
ingester.Collection)
ingester.ConceptEntity = authorization.apply_filter(
creator, 'change_conceptentity', ingester.ConceptEntity)
ingester.set_resource_defaults(entity_type=default_type,
created_by=creator,
**form_data)
N = len(ingester)
for resource in ingester:
collection.resources.add(resource)
operations.add_creation_metadata(resource, creator)
authorization.update_authorizations(Resource.DEFAULT_AUTHS,
creator,
resource,
propagate=True)
if job:
job.progress += 1. / N
job.save()
job.result = jsonpickle.encode({'view': 'collection', 'id': collection.id})
job.save()
return {'view': 'collection', 'id': collection.id}
def handle_bulk(self,
file_path,
form_data,
file_name,
job=None,
ingester='cookies.accession.zotero.ZoteroIngest'):
"""
Process resource data in a RDF document.
Parameters
----------
file_path : str
Local path to a RDF document, or a ZIP file containing a Zotero RDF
export (with files).
form_data : dict
Valid data from a :class:`cookies.forms.BulkResourceForm`\.
file_name : str
Name of the target file at ``file_path``\.
job : :class:`.UserJob`
Used to update progress.
"""
if job:
job.result_id = self.request.id
job.save()
logger.debug('handle bulk')
creator = form_data.pop('created_by')
# The user can either add these new records to an existing collection, or
# create a new one.
collection = form_data.pop('collection', None)
collection_name = form_data.pop('name', None)
public_policy = False
if not collection:
collection = Collection.objects.create(**{
'name': collection_name,
'created_by': creator,
})
operations.add_creation_metadata(collection, creator)
if form_data.get('public'):
# Create an authoirzation for AnonymousUser.
CollectionAuthorization.objects.create(
granted_by=creator,
granted_to=None,
for_resource=collection,
policy=CollectionAuthorization.ALLOW,
action=CollectionAuthorization.VIEW)
public_policy = True
# User can indicate a default Type to assign to each new Resource.
default_type = form_data.pop('default_type', None)
upload_resource = Resource.objects.create(
created_by=creator,
name=file_name,
)
with open(file_path, 'r') as f:
upload_resource.file.save(file_name, File(f), True)
ingester = IngesterFactory().get(ingester)(upload_resource.file.path)
ingester.Resource = authorization.apply_filter(ResourceAuthorization.EDIT,
creator, ingester.Resource)
ingester.Collection = authorization.apply_filter(
ResourceAuthorization.EDIT, creator, ingester.Collection)
ingester.ConceptEntity = authorization.apply_filter(
ResourceAuthorization.EDIT, creator, ingester.ConceptEntity)
ingester.set_resource_defaults(entity_type=default_type,
collection=collection,
created_by=creator,
**form_data)
ingester.set_collection(collection)
N = len(ingester)
resource_auths = []
for resource in ingester:
resource.container.part_of = collection
if form_data.get('public') and not public_policy:
resource_auths.append(
ResourceAuthorization(granted_by=creator,
granted_to=None,
for_resource=resource.container,
policy=ResourceAuthorization.ALLOW,
action=ResourceAuthorization.VIEW))
resource.container.save()
# collection.resources.add(resource)
operations.add_creation_metadata(resource, creator)
if job:
job.progress += 1. / N
job.save()
ResourceAuthorization.objects.bulk_create(resource_auths)
job.result = jsonpickle.encode({'view': 'collection', 'id': collection.id})
job.save()
return {'view': 'collection', 'id': collection.id}
