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}