def tags_view(request, tag, klass):
"""View all items tagged by given tag in given klass.
@param request: request data
@type request: Django request
@param tag: name of the tag
@type tag: string
@param klass: klass of tagged item
@type klass: repository.Data/Task/Method
@return: rendered response page
@rtype: Django response
@raise Http404: if tag doesn't exist or no items are tagged by given tag
"""
try:
tag = Tag.objects.get(name=tag)
objects = klass.get_current_tagged_items(request.user, tag)
if not objects: raise Http404
except Tag.DoesNotExist:
raise Http404
PER_PAGE = get_per_page(len(objects))
kname = klass.__name__.lower()
info_dict = {
'request': request,
'tag': tag,
'tagcloud': get_tag_clouds(request),
kname : get_page(request, objects, PER_PAGE),
'klass' : klass.__name__,
kname + '_per_page': PER_PAGE,
'section': 'repository',
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
}
return render_to_response('repository/item_index.html', info_dict,
context_instance=RequestContext(request))
def index(request, klass, my=False, order_by='-pub_date', filter_type=None):
"""Index/My page for section given by klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@param my: if the page should be a My page or the archive index of the section
@type my: boolean
@return: section's index or My page
@rtype: Django response
"""
objects = klass.objects.filter(is_deleted=False)
if klass == Task and filter_type:
objects = objects.filter(type=filter_type)
if klass == Data:
objects = objects.filter(is_approved=True)
if my and request.user.is_authenticated():
objects = objects.filter(user=request.user, is_current=True)
if klass == Data:
unapproved = klass.objects.filter(user=request.user,
is_approved=False)
else:
unapproved = None
my_or_archive = _('My')
else:
objects = objects.filter(is_current=True, is_public=True)
unapproved = None
my_or_archive = _('Public Archive')
objects = objects.order_by(order_by, '-pub_date')
kname = klass.__name__.lower()
PER_PAGE = get_per_page(objects.count())
info_dict = {
'request': request,
kname: get_page(request, objects, PER_PAGE),
kname + '_per_page': PER_PAGE,
'klass': klass.__name__,
'unapproved':
get_page(request, unapproved, PER_PAGE) if unapproved else [],
'my_or_archive': my_or_archive,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
'yeah': 'index',
}
return render_to_response('repository/item_index.html',
info_dict,
context_instance=RequestContext(request))
def index(request, klass, my=False, order_by='-pub_date', filter_type=None):
"""Index/My page for section given by klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@param my: if the page should be a My page or the archive index of the section
@type my: boolean
@return: section's index or My page
@rtype: Django response
"""
objects = klass.objects.filter(is_deleted=False)
if klass == Task and filter_type:
objects = objects.filter(type=filter_type)
if klass == Data:
objects = objects.filter(is_approved=True)
if my and request.user.is_authenticated():
objects = objects.filter(user=request.user, is_current=True)
if klass == Data:
unapproved = klass.objects.filter(
user=request.user, is_approved=False
)
else:
unapproved = None
my_or_archive = _('My')
else:
objects = objects.filter(is_current=True, is_public=True)
unapproved = None
my_or_archive = _('Public Archive')
objects = objects.order_by(order_by, '-pub_date')
kname=klass.__name__.lower()
PER_PAGE = get_per_page(objects.count())
info_dict = {
'request': request,
kname : get_page(request, objects, PER_PAGE),
kname + '_per_page': PER_PAGE,
'klass' : klass.__name__,
'unapproved': unapproved,
'my_or_archive': my_or_archive,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
'yeah': 'index',
}
return render_to_response('repository/item_index.html',
info_dict, context_instance=RequestContext(request))
def search(request):
"""Search the repository for given term.
@param request: request data
@type request: Django request
@return: rendered response page
@rtype: Django response
"""
if request.method == 'GET' and 'searchterm' in request.GET:
searchterm = request.GET['searchterm']
classes = []
for c in (Data, Task, Method, Challenge):
kname = c.__name__.lower()
if kname in request.GET:
classes.append(c)
info_dict = {
'request': request,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
'yeah': 'search',
'my_or_archive': _('Search Results for "%s"' % searchterm)
}
for klass in classes:
objects = klass.objects.filter(is_deleted=False,
is_current=True,
is_public=True)
if klass == Data:
objects = objects.filter(is_approved=True)
searcherror = True
if searchterm:
info_dict['searchterm'] = searchterm
objects = objects.filter(
Q(name__icontains=searchterm)
| Q(summary__icontains=searchterm)).order_by('-pub_date')
searcherror = objects.count() == 0
kname = klass.__name__.lower()
PER_PAGE = get_per_page(objects.count())
info_dict[kname] = get_page(request, objects, PER_PAGE)
info_dict[kname + '_per_page'] = PER_PAGE
info_dict[kname + '_searcherror'] = searcherror
return render_to_response('repository/item_index.html',
info_dict,
context_instance=RequestContext(request))
raise Http404
def search(request):
"""Search the repository for given term.
@param request: request data
@type request: Django request
@return: rendered response page
@rtype: Django response
"""
if request.method == 'GET' and 'searchterm' in request.GET:
searchterm = request.GET['searchterm']
classes=[]
for c in (Data, Task, Method, Challenge):
kname=c.__name__.lower()
if kname in request.GET:
classes.append(c)
info_dict = {
'request': request,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
'yeah': 'search',
'my_or_archive' : _('Search Results for "%s"' % searchterm)
}
for klass in classes:
objects = klass.objects.filter(is_deleted=False, is_current=True, is_public=True)
if klass == Data:
objects = objects.filter(is_approved=True)
searcherror = True
if searchterm:
info_dict['searchterm'] = searchterm
objects = objects.filter(Q(name__icontains=searchterm) |
Q(summary__icontains=searchterm)).order_by('-pub_date')
searcherror = objects.count()==0
kname=klass.__name__.lower()
PER_PAGE = get_per_page(objects.count())
info_dict[kname]=get_page(request, objects, PER_PAGE)
info_dict[kname + '_per_page']=PER_PAGE
info_dict[kname + '_searcherror']=searcherror
return render_to_response('repository/item_index.html', info_dict,
context_instance=RequestContext(request))
raise Http404
def main_index(request):
"""Index page of app repository.
@param request: request data
@type request: Django request
@return: rendered response page
@rtype: Django response
"""
info_dict = {
'request': request,
'section': 'repository',
'tagcloud': get_tag_clouds(request),
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
'yeah': 'main_index',
}
return render_to_response('repository/index.html', info_dict,
context_instance=RequestContext(request))
def main_index(request):
"""Index page of app repository.
@param request: request data
@type request: Django request
@return: rendered response page
@rtype: Django response
"""
info_dict = {
'request': request,
'section': 'repository',
'tagcloud': get_tag_clouds(request),
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
'yeah': 'main_index',
}
return render_to_response('repository/index.html',
info_dict,
context_instance=RequestContext(request))
def tags_view(request, tag, klass):
"""View all items tagged by given tag in given klass.
@param request: request data
@type request: Django request
@param tag: name of the tag
@type tag: string
@param klass: klass of tagged item
@type klass: repository.Data/Task/Method
@return: rendered response page
@rtype: Django response
@raise Http404: if tag doesn't exist or no items are tagged by given tag
"""
try:
tag = Tag.objects.get(name=tag)
objects = klass.get_current_tagged_items(request.user, tag)
if not objects: raise Http404
except Tag.DoesNotExist:
raise Http404
PER_PAGE = get_per_page(len(objects))
kname = klass.__name__.lower()
info_dict = {
'request': request,
'tag': tag,
'tagcloud': get_tag_clouds(request),
kname: get_page(request, objects, PER_PAGE),
'klass': klass.__name__,
kname + '_per_page': PER_PAGE,
'section': 'repository',
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
}
return render_to_response('repository/item_index.html',
info_dict,
context_instance=RequestContext(request))
def fork(request, klass, id):
"""Create a new item of given klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@return: user login page, item's view page or this page again on failed form validation
@rtype: Django response
@raise Http404: if given klass is unexpected
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('user_signin') + '?next=' + request.path)
prev = klass.get_object(id)
if not prev: raise Http404
if not prev.can_fork(request.user):
return HttpResponseForbidden()
prev.klass = klass.__name__
prev.name+=' (forked)'
upload_limit = Preferences.objects.get(pk=1).max_data_size
formfunc = eval(klass.__name__ + 'Form')
if request.method == 'POST':
form = formfunc(request.POST, request.FILES, request=request)
# manual validation coz it's required for new, but not edited Data
if not request.FILES and klass == Data:
form.errors['file'] = ErrorDict({'': _('This field is required.')}).as_ul()
# check whether file is too large
if klass in (Data, Task) and 'file' in request.FILES:
if len(request.FILES['file']) > upload_limit:
form.errors['file'] = ErrorDict({'': _('File is too large! Must be smaller than %dMB!' % (upload_limit / MEGABYTE))}).as_ul()
if form.is_valid():
new = form.save(commit=False)
new.pub_date = datetime.datetime.now()
try:
new.slug = new.make_slug()
except IntegrityError:
# looks quirky...
d = ErrorDict({'':
_('The given name yields an already existing slug. Please try another name.')})
form.errors['name'] = d.as_ul()
else:
new.version = 1
new.is_current = True
new.is_public = False
new.user = request.user
if not form.cleaned_data['keep_private']:
new.is_public = True
if klass == Data:
new.file = request.FILES['file']
new.num_instances = -1
new.num_attributes = -1
new.save()
# InMemoryUploadedFile returns file-like object whereas
# zipfile/tarfile modules used in get_uncompressed() require
# filename (prior to python 2.7), so we have to save it to
# disk, then rename, then save object again.
name_old = os.path.join(MEDIA_ROOT, new.file.name)
uncompressed = ml2h5.data.get_uncompressed(name_old)
if uncompressed:
os.remove(name_old)
name_old = uncompressed
new.format = ml2h5.fileformat.get(name_old)
name_new = os.path.join(DATAPATH, new.get_filename())
os.rename(name_old, os.path.join(MEDIA_ROOT, name_new))
new.file.name = name_new
new.save()
elif klass == Task:
taskinfo = {
'train_idx': (form.cleaned_data['train_idx']),
'test_idx': (form.cleaned_data['test_idx']),
'input_variables': form.cleaned_data['input_variables'],
'output_variables': form.cleaned_data['output_variables']
}
new.file = None
if 'file' in request.FILES:
new.file = request.FILES['file']
new.save()
new.create_next_file(prev=None)
else:
new.save(taskinfo=taskinfo)
new.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
new.save(taskinfo=taskinfo)
elif klass == Method:
#if 'score' in request.FILES:
# new.score = request.FILES['score']
# new.score.name = new.get_scorename()
new.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
new.save()
elif klass == Challenge:
new.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
new.save()
new.task=form.cleaned_data['task']
new.save()
else:
raise Http404
return HttpResponseRedirect(new.get_absolute_slugurl())
else:
form = formfunc(request=request, instance=prev)
info_dict = {
'klass': klass.__name__,
'uuid': uuid.uuid4(), # for upload progress bar
'url_new': request.path,
'form': form,
'request': request,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'upload_limit': "%dMB" % (upload_limit / MEGABYTE)
}
return _response_for(request, klass, 'item_new', info_dict)
def edit(request, klass, id):
"""Edit existing item given by slug or id and klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@param id: id of the item to activate
@type id: integer
@return: user login page, item's view page or this page again on failed form validation
@rtype: Django response
@raise Http404: if item couldn't be found or given klass is unexpected
"""
prev = klass.get_object(id)
if not prev: raise Http404
prev.klass = klass.__name__
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('user_signin') + '?next=' + request.path)
if not prev.can_edit(request.user):
return HttpResponseForbidden()
upload_limit = Preferences.objects.get(pk=1).max_data_size
formfunc = eval(klass.__name__ + 'Form')
if request.method == 'POST':
request.POST['name'] = prev.name # cheat a little
form = formfunc(request.POST, request=request)
_validate_file_size(request, form, klass)
if form.is_valid():
next = form.save(commit=False)
next.pub_date = datetime.datetime.now()
next.slug = prev.slug
next.version = next.get_next_version()
next.user = request.user
if prev.is_public: # once public, always public
next.is_public = True
elif not form.cleaned_data['keep_private']:
next.is_public = True
if klass == Data:
next.is_approved = prev.is_approved
if next.is_public or not request.FILES['file']:
next.format = prev.format
next.file = prev.file
else:
_upload_data_file(next, request.FILES['file'])
next.save()
elif klass == Task:
next.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
taskinfo = {
'train_idx': form.cleaned_data['train_idx'],
'val_idx': form.cleaned_data['val_idx'],
'test_idx': form.cleaned_data['test_idx'],
'input_variables': form.cleaned_data['input_variables'],
'output_variables': form.cleaned_data['output_variables'],
'data_size': prev.data.num_instances
}
next.file = None
if 'file' in request.FILES:
next.file = request.FILES['file']
next.save()
next.create_next_file(prev)
else:
next.save(taskinfo=taskinfo)
elif klass == Method:
next.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
next.save()
elif klass == Challenge:
next.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
next.save()
else:
raise Http404
form.save_m2m() # for publications
klass.set_current(next)
return HttpResponseRedirect(next.get_absolute_slugurl())
else:
form = formfunc(instance=prev, request=request, initial={'keep_private': not prev.is_public})
if klass == Task:
form.prefill(os.path.join(MEDIA_ROOT, prev.file.name))
info_dict = {
'form': form,
'object': prev,
'request': request,
'publication_form': PublicationForm(),
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'extract': prev.get_extract(),
}
return _response_for(request, klass, 'item_edit', info_dict)
def new(request, klass, default_arg=None):
"""Create a new item of given klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@return: user login page, item's view page or this page again on failed form validation
@rtype: Django response
@raise Http404: if given klass is unexpected
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(reverse('user_signin') + '?next=' + request.path)
upload_limit = Preferences.objects.get(pk=1).max_data_size
formfunc = eval(klass.__name__ + 'Form')
if request.method == 'POST':
form = formfunc(request.POST, request.FILES, request=request)
# manual validation coz it's required for new, but not edited Data
if not request.FILES and klass == Data:
form.errors['file'] = ErrorDict({'': _('This field is required.')}).as_ul()
_validate_file_size(request, form, klass)
if form.is_valid():
new = form.save(commit=False)
new.pub_date = datetime.datetime.now()
try:
new.slug = new.make_slug()
except IntegrityError:
# looks quirky...
d = ErrorDict({'':
_('The given name yields an already existing slug. Please try another name.')})
form.errors['name'] = d.as_ul()
else:
new.version = 1
new.is_current = True
new.is_public = False
new.user = request.user
if not form.cleaned_data['keep_private']:
new.is_public = True
if klass == Data:
_upload_data_file(new, request.FILES['file'])
new.save()
form.save_m2m() # it couldn't be done automatically because of commit=False
elif klass == Task:
new.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
taskinfo = {
'train_idx': (form.cleaned_data['train_idx']),
'val_idx': (form.cleaned_data['val_idx']),
'test_idx': (form.cleaned_data['test_idx']),
'input_variables': form.cleaned_data['input_variables'],
'output_variables': form.cleaned_data['output_variables'],
'data_size': form.cleaned_data['data'].num_instances
}
new.file = None
if 'file' in request.FILES:
new.file = request.FILES['file']
new.save()
new.create_next_file(prev=None)
else:
new.save(taskinfo=taskinfo)
elif klass == Method:
#if 'score' in request.FILES:
# new.score = request.FILES['score']
# new.score.name = new.get_scorename()
new.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
new.save()
elif klass == Challenge:
new.license = FixedLicense.objects.get(pk=1) # fixed to CC-BY-SA
new.save()
new.task=form.cleaned_data['task']
new.save()
else:
raise Http404
return HttpResponseRedirect(new.get_absolute_slugurl())
else:
if default_arg:
form = formfunc(request=request, default_arg=default_arg)
else:
form = formfunc(request=request)
kname=klass.__name__.lower()
info_dict = {
'klass': klass.__name__,
kname: True,
'uuid': uuid.uuid4(), # for upload progress bar
'url_new': request.path,
'form': form,
'request': request,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'upload_limit': "%dMB" % (upload_limit / MEGABYTE)
}
return _response_for(request, klass, 'item_new', info_dict)
def view(request, klass, slug_or_id, version=None):
"""View item given by slug and klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@param slug_or_id: slug or id of the item to view
@type slug_or_id: string or integer
@return: view page or review page if klass Data and item not approved
@rtype: Django response
@raise Http404: if item couldn't be found
"""
kname=klass.__name__.lower()
obj = klass.get_object(slug_or_id, version)
if not obj: raise Http404
if not obj.can_view(request.user):
return HttpResponseForbidden()
if not obj.check_is_approved():
return HttpResponseRedirect(reverse(kname + '_review', args=[obj.slug]))
current = obj.update_current_hits()
# need tags in list
versions = get_versions_paginator(request, obj)
info_dict = {
'object': obj,
'request': request,
'can_edit': obj.can_edit(request.user),
'can_activate': obj.can_activate(request.user),
'can_delete': obj.can_delete(request.user),
'dependent_entries_exist': obj.dependent_entries_exist(),
'dependent_link': '',
'current': current,
'rating_form': RatingForm.get(request, obj),
'tagcloud': get_tag_clouds(request),
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
kname : True,
'klass': klass.__name__,
'section': 'repository',
'versions': versions,
}
if request.method == 'GET' and 'c' in request.GET:
info_dict['show_comments'] = True
if klass == Data:
tasks=obj.get_related_tasks(request.user)
PER_PAGE = get_per_page(tasks.count())
info_dict['page']=get_page(request, tasks, PER_PAGE)
info_dict['per_page']=PER_PAGE
info_dict['related_tasks']=tasks
info_dict['dependent_link']='#tabs-method'
else:
if request.user.is_authenticated():
form = handle_result_form(request)
info_dict['result_form'] = form
if klass == Task:
objects=Result.objects.filter(task=obj)
if request.user.is_authenticated():
form.fields['task'].queryset = obj
form.fields['challenge'].queryset = obj.get_challenges()
PER_PAGE = get_per_page(objects.count())
info_dict['page']=get_page(request, objects, PER_PAGE)
info_dict['per_page']=PER_PAGE
info_dict['data']=obj.get_data()
info_dict['dependent_link']='foo'
elif klass == Method:
objects=Result.objects.filter(method=obj)
PER_PAGE = get_per_page(objects.count())
info_dict['page']=get_page(request, objects, PER_PAGE)
info_dict['per_page']=PER_PAGE
elif klass == Challenge:
t=obj.get_tasks()
if request.user.is_authenticated():
form.fields['task'].queryset = t
form.fields['challenge'] = obj
info_dict['tasks']=t
objects=Result.objects.filter(challenge=obj).order_by('task__name','aggregation_score')
PER_PAGE = get_per_page(objects.count())
info_dict['page']=get_page(request, objects, PER_PAGE)
info_dict['per_page']=PER_PAGE
if hasattr(obj, 'data_heldback') and obj.data_heldback:
info_dict['can_view_heldback'] = obj.data_heldback.can_view(request.user)
info_dict['extract'] = obj.get_extract()
return _response_for(request, klass, 'item_view', info_dict)
def fork(request, klass, id):
"""Create a new item of given klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@return: user login page, item's view page or this page again on failed form validation
@rtype: Django response
@raise Http404: if given klass is unexpected
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(
reverse('user_signin') + '?next=' + request.path)
prev = klass.get_object(id)
if not prev: raise Http404
if not prev.can_fork(request.user):
return HttpResponseForbidden()
prev.klass = klass.__name__
prev.name += ' (forked)'
upload_limit = Preferences.objects.get(pk=1).max_data_size
formfunc = eval(klass.__name__ + 'Form')
if request.method == 'POST':
form = formfunc(request.POST, request.FILES, request=request)
# manual validation coz it's required for new, but not edited Data
if not request.FILES and klass == Data:
form.errors['file'] = ErrorDict({
'': _('This field is required.')
}).as_ul()
# check whether file is too large
if klass in (Data, Task) and 'file' in request.FILES:
if len(request.FILES['file']) > upload_limit:
form.errors['file'] = ErrorDict({
'':
_('File is too large! Must be smaller than %dMB!' %
(upload_limit / MEGABYTE))
}).as_ul()
if form.is_valid():
new = form.save(commit=False)
new.pub_date = datetime.datetime.now()
try:
new.slug = new.make_slug()
except IntegrityError:
# looks quirky...
d = ErrorDict({
'':
_('The given name yields an already existing slug. Please try another name.'
)
})
form.errors['name'] = d.as_ul()
else:
new.version = 1
new.is_current = True
new.is_public = False
new.user = request.user
if not form.cleaned_data['keep_private']:
new.is_public = True
if klass == Data:
new.file = request.FILES['file']
new.num_instances = -1
new.num_attributes = -1
new.save()
# InMemoryUploadedFile returns file-like object whereas
# zipfile/tarfile modules used in get_uncompressed() require
# filename (prior to python 2.7), so we have to save it to
# disk, then rename, then save object again.
name_old = os.path.join(MEDIA_ROOT, new.file.name)
uncompressed = ml2h5.data.get_uncompressed(name_old)
if uncompressed:
os.remove(name_old)
name_old = uncompressed
new.format = ml2h5.fileformat.get(name_old)
name_new = os.path.join(DATAPATH, new.get_filename())
os.rename(name_old, os.path.join(MEDIA_ROOT, name_new))
new.file.name = name_new
new.save()
elif klass == Task:
taskinfo = {
'train_idx': (form.cleaned_data['train_idx']),
'test_idx': (form.cleaned_data['test_idx']),
'input_variables':
form.cleaned_data['input_variables'],
'output_variables':
form.cleaned_data['output_variables']
}
new.file = None
if 'file' in request.FILES:
new.file = request.FILES['file']
new.save()
new.create_next_file(prev=None)
else:
new.save(taskinfo=taskinfo)
new.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
new.save(taskinfo=taskinfo)
elif klass == Method:
#if 'score' in request.FILES:
# new.score = request.FILES['score']
# new.score.name = new.get_scorename()
new.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
new.save()
elif klass == Challenge:
new.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
new.save()
new.task = form.cleaned_data['task']
new.save()
else:
raise Http404
return HttpResponseRedirect(new.get_absolute_slugurl())
else:
form = formfunc(request=request, instance=prev)
info_dict = {
'klass': klass.__name__,
'uuid': uuid.uuid4(), # for upload progress bar
'url_new': request.path,
'form': form,
'request': request,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'upload_limit': "%dMB" % (upload_limit / MEGABYTE)
}
return _response_for(request, klass, 'item_new', info_dict)
def edit(request, klass, id):
"""Edit existing item given by slug or id and klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@param id: id of the item to activate
@type id: integer
@return: user login page, item's view page or this page again on failed form validation
@rtype: Django response
@raise Http404: if item couldn't be found or given klass is unexpected
"""
prev = klass.get_object(id)
if not prev: raise Http404
prev.klass = klass.__name__
if not request.user.is_authenticated():
return HttpResponseRedirect(
reverse('user_signin') + '?next=' + request.path)
if not prev.can_edit(request.user):
return HttpResponseForbidden()
upload_limit = Preferences.objects.get(pk=1).max_data_size
formfunc = eval(klass.__name__ + 'Form')
if request.method == 'POST':
request.POST['name'] = prev.name # cheat a little
form = formfunc(request.POST, request=request)
_validate_file_size(request, form, klass)
if form.is_valid():
next = form.save(commit=False)
next.pub_date = datetime.datetime.now()
next.slug = prev.slug
next.version = next.get_next_version()
next.user = request.user
if prev.is_public: # once public, always public
next.is_public = True
elif not form.cleaned_data['keep_private']:
next.is_public = True
if klass == Data:
next.is_approved = prev.is_approved
if next.is_public or not request.FILES['file']:
next.format = prev.format
next.file = prev.file
else:
_upload_data_file(next, request.FILES['file'])
next.save()
elif klass == Task:
next.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
taskinfo = {
'train_idx': form.cleaned_data['train_idx'],
'val_idx': form.cleaned_data['val_idx'],
'test_idx': form.cleaned_data['test_idx'],
'input_variables': form.cleaned_data['input_variables'],
'output_variables': form.cleaned_data['output_variables'],
'data_size': prev.data.num_instances
}
next.file = None
if 'file' in request.FILES:
next.file = request.FILES['file']
next.save()
next.create_next_file(prev)
else:
next.save(taskinfo=taskinfo)
elif klass == Method:
next.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
next.save()
elif klass == Challenge:
next.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
next.save()
else:
raise Http404
form.save_m2m() # for publications
klass.set_current(next)
return HttpResponseRedirect(next.get_absolute_slugurl())
else:
form = formfunc(instance=prev,
request=request,
initial={'keep_private': not prev.is_public})
if klass == Task:
form.prefill(os.path.join(MEDIA_ROOT, prev.file.name))
info_dict = {
'form': form,
'object': prev,
'request': request,
'publication_form': PublicationForm(),
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'extract': prev.get_extract(),
}
return _response_for(request, klass, 'item_edit', info_dict)
def new(request, klass, default_arg=None):
"""Create a new item of given klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@return: user login page, item's view page or this page again on failed form validation
@rtype: Django response
@raise Http404: if given klass is unexpected
"""
if not request.user.is_authenticated():
return HttpResponseRedirect(
reverse('user_signin') + '?next=' + request.path)
upload_limit = Preferences.objects.get(pk=1).max_data_size
formfunc = eval(klass.__name__ + 'Form')
if request.method == 'POST':
form = formfunc(request.POST, request.FILES, request=request)
# manual validation coz it's required for new, but not edited Data
if not request.FILES and klass == Data:
form.errors['file'] = ErrorDict({
'': _('This field is required.')
}).as_ul()
_validate_file_size(request, form, klass)
if form.is_valid():
new = form.save(commit=False)
new.pub_date = datetime.datetime.now()
try:
new.slug = new.make_slug()
except IntegrityError:
# looks quirky...
d = ErrorDict({
'':
_('The given name yields an already existing slug. Please try another name.'
)
})
form.errors['name'] = d.as_ul()
else:
new.version = 1
new.is_current = True
new.is_public = False
new.user = request.user
if not form.cleaned_data['keep_private']:
new.is_public = True
if klass == Data:
_upload_data_file(new, request.FILES['file'])
new.save()
form.save_m2m(
) # it couldn't be done automatically because of commit=False
elif klass == Task:
new.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
taskinfo = {
'train_idx': (form.cleaned_data['train_idx']),
'val_idx': (form.cleaned_data['val_idx']),
'test_idx': (form.cleaned_data['test_idx']),
'input_variables':
form.cleaned_data['input_variables'],
'output_variables':
form.cleaned_data['output_variables'],
'data_size': form.cleaned_data['data'].num_instances
}
new.file = None
if 'file' in request.FILES:
new.file = request.FILES['file']
new.save()
new.create_next_file(prev=None)
else:
new.save(taskinfo=taskinfo)
elif klass == Method:
#if 'score' in request.FILES:
# new.score = request.FILES['score']
# new.score.name = new.get_scorename()
new.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
new.save()
elif klass == Challenge:
new.license = FixedLicense.objects.get(
pk=1) # fixed to CC-BY-SA
new.save()
new.task = form.cleaned_data['task']
new.save()
else:
raise Http404
return HttpResponseRedirect(new.get_absolute_slugurl())
else:
if default_arg:
form = formfunc(request=request, default_arg=default_arg)
else:
form = formfunc(request=request)
kname = klass.__name__.lower()
info_dict = {
'klass': klass.__name__,
kname: True,
'uuid': uuid.uuid4(), # for upload progress bar
'url_new': request.path,
'form': form,
'request': request,
'tagcloud': get_tag_clouds(request),
'section': 'repository',
'upload_limit': "%dMB" % (upload_limit / MEGABYTE)
}
return _response_for(request, klass, 'item_new', info_dict)
def view(request, klass, slug_or_id, version=None):
"""View item given by slug and klass.
@param request: request data
@type request: Django request
@param klass: item's class for lookup in correct database table
@type klass: either Data, Task or Method
@param slug_or_id: slug or id of the item to view
@type slug_or_id: string or integer
@return: view page or review page if klass Data and item not approved
@rtype: Django response
@raise Http404: if item couldn't be found
"""
kname = klass.__name__.lower()
obj = klass.get_object(slug_or_id, version)
if not obj: raise Http404
if not obj.can_view(request.user):
return HttpResponseForbidden()
if not obj.check_is_approved():
return HttpResponseRedirect(reverse(kname + '_review',
args=[obj.slug]))
current = obj.update_current_hits()
# need tags in list
versions = get_versions_paginator(request, obj)
info_dict = {
'object': obj,
'request': request,
'can_edit': obj.can_edit(request.user),
'can_activate': obj.can_activate(request.user),
'can_delete': obj.can_delete(request.user),
'dependent_entries_exist': obj.dependent_entries_exist(),
'dependent_link': '',
'current': current,
'rating_form': RatingForm.get(request, obj),
'tagcloud': get_tag_clouds(request),
'download_warning_limit': DOWNLOAD_WARNING_LIMIT,
kname: True,
'klass': klass.__name__,
'section': 'repository',
'versions': versions,
}
if request.method == 'GET' and 'c' in request.GET:
info_dict['show_comments'] = True
if klass == Data:
tasks = obj.get_related_tasks(request.user)
PER_PAGE = get_per_page(tasks.count())
info_dict['page'] = get_page(request, tasks, PER_PAGE)
info_dict['per_page'] = PER_PAGE
info_dict['related_tasks'] = tasks
info_dict['dependent_link'] = '#tabs-method'
else:
if request.user.is_authenticated():
form = handle_result_form(request)
info_dict['result_form'] = form
if klass == Task:
objects = Result.objects.filter(task=obj)
if request.user.is_authenticated():
form.fields['task'].queryset = obj
form.fields['challenge'].queryset = obj.get_challenges()
PER_PAGE = get_per_page(objects.count())
info_dict['page'] = get_page(request, objects, PER_PAGE)
info_dict['per_page'] = PER_PAGE
info_dict['data'] = obj.get_data()
info_dict['dependent_link'] = 'foo'
elif klass == Method:
objects = Result.objects.filter(method=obj)
PER_PAGE = get_per_page(objects.count())
info_dict['page'] = get_page(request, objects, PER_PAGE)
info_dict['per_page'] = PER_PAGE
elif klass == Challenge:
t = obj.get_tasks()
if request.user.is_authenticated():
form.fields['task'].queryset = t
form.fields['challenge'] = obj
info_dict['tasks'] = t
objects = Result.objects.filter(challenge=obj).order_by(
'task__name', 'aggregation_score')
PER_PAGE = get_per_page(objects.count())
info_dict['page'] = get_page(request, objects, PER_PAGE)
info_dict['per_page'] = PER_PAGE
if hasattr(obj, 'data_heldback') and obj.data_heldback:
info_dict['can_view_heldback'] = obj.data_heldback.can_view(
request.user)
info_dict['extract'] = obj.get_extract()
return _response_for(request, klass, 'item_view', info_dict)
