def upload_file(request, package, version, **kwargs):
release = get_object_or_404(Package, name=package).get_release(version)
if not release:
raise Http404('Version %s does not exist for %s' % (version,
package,))
kwargs.setdefault('form_factory', DistributionUploadForm)
kwargs.setdefault('post_save_redirect', reverse('packageindex-release-manage-files',
kwargs={'package': package,
'version': version}))
kwargs.setdefault('template_name', 'packageindex/release_upload_file.html')
kwargs.setdefault('template_object_name', 'release')
kwargs.setdefault('extra_context', {})
kwargs.setdefault('mimetype', settings.DEFAULT_CONTENT_TYPE)
kwargs['extra_context'][kwargs['template_object_name']] = release
if request.method == 'POST':
form = kwargs['form_factory'](data=request.POST, files=request.FILES)
if form.is_valid():
dist = form.save(commit=False)
dist.release = release
dist.uploader = request.user
dist.save()
return create_update.redirect(kwargs.get('post_save_redirect'),
release)
else:
form = kwargs['form_factory']()
kwargs['extra_context']['form'] = form
return render_to_response(kwargs['template_name'], kwargs['extra_context'],
context_instance=RequestContext(request),
mimetype=kwargs['mimetype'])
def manage_versions(request, package, **kwargs):
package = get_object_or_404(Package, name=package)
kwargs.setdefault('formset_factory_kwargs', {})
kwargs['formset_factory_kwargs'].setdefault('fields', ('hidden',))
kwargs['formset_factory_kwargs']['extra'] = 0
kwargs.setdefault('formset_factory', inlineformset_factory(Package, Release, **kwargs['formset_factory_kwargs']))
kwargs.setdefault('template_name', 'djangopypi/package_manage_versions.html')
kwargs.setdefault('template_object_name', 'package')
kwargs.setdefault('extra_context',{})
kwargs.setdefault('mimetype',settings.DEFAULT_CONTENT_TYPE)
kwargs['extra_context'][kwargs['template_object_name']] = package
kwargs.setdefault('formset_kwargs',{})
kwargs['formset_kwargs']['instance'] = package
if request.method == 'POST':
formset = kwargs['formset_factory'](data=request.POST, **kwargs['formset_kwargs'])
if formset.is_valid():
formset.save()
return create_update.redirect(kwargs.get('post_save_redirect', None),
package)
formset = kwargs['formset_factory'](**kwargs['formset_kwargs'])
kwargs['extra_context']['formset'] = formset
return render_to_response(kwargs['template_name'], kwargs['extra_context'],
context_instance=RequestContext(request),
mimetype=kwargs['mimetype'])
def upload_file(request, package, version, **kwargs):
release = get_object_or_404(Package, name=package).get_release(version)
if not release:
raise Http404('Version %s does not exist for %s' % (version,
package,))
kwargs.setdefault('form_factory', DistributionUploadForm)
kwargs.setdefault('post_save_redirect', reverse('djangopypi-release-manage-files',
kwargs={'package': package,
'version': version}))
kwargs.setdefault('template_name', 'djangopypi/release_upload_file.html')
kwargs.setdefault('template_object_name', 'release')
kwargs.setdefault('extra_context',{})
kwargs.setdefault('mimetype',settings.DEFAULT_CONTENT_TYPE)
kwargs['extra_context'][kwargs['template_object_name']] = release
if request.method == 'POST':
form = kwargs['form_factory'](data=request.POST, files=request.FILES)
if form.is_valid():
dist = form.save(commit=False)
dist.release = release
dist.uploader = request.user
dist.save()
return create_update.redirect(kwargs.get('post_save_redirect'),
release)
else:
form = kwargs['form_factory']()
kwargs['extra_context']['form'] = form
return render_to_response(kwargs['template_name'], kwargs['extra_context'],
context_instance=RequestContext(request),
mimetype=kwargs['mimetype'])
def task_create(
request,
model=None,
template_name=None,
extra_context=None,
post_save_redirect=None,
login_required=False,
context_processors=None,
form_class=None,
):
if extra_context is None:
extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
if request.method == "POST":
p = Project.objects.get_or_create_by_owner_and_title(request.user, request.POST.get("project_title_inbox"))
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save(commit=False)
new_object.project = p
new_object.save()
msg = ugettext("The %(verbose_name)s was created successfully.") % {
"verbose_name": model._meta.verbose_name
}
messages.success(request, msg, fail_silently=True)
return redirect(post_save_redirect, new_object)
else:
form = form_class()
if not template_name:
template_name = "%s/%s_insert_form.html" % (model._meta.app_label, model._meta.object_name.lower())
return render_to_response(template_name, {"form": form}, RequestContext(request))
def manage_versions(request, package, **kwargs):
package = get_object_or_404(Package, name=package)
kwargs.setdefault('formset_factory_kwargs', {})
kwargs['formset_factory_kwargs'].setdefault('fields', ('hidden', ))
kwargs['formset_factory_kwargs']['extra'] = 0
kwargs.setdefault(
'formset_factory',
inlineformset_factory(Package, Release,
**kwargs['formset_factory_kwargs']))
kwargs.setdefault('template_name',
'djangopypi/package_manage_versions.html')
kwargs.setdefault('template_object_name', 'package')
kwargs.setdefault('extra_context', {})
kwargs.setdefault('mimetype', settings.DEFAULT_CONTENT_TYPE)
kwargs['extra_context'][kwargs['template_object_name']] = package
kwargs.setdefault('formset_kwargs', {})
kwargs['formset_kwargs']['instance'] = package
if request.method == 'POST':
formset = kwargs['formset_factory'](data=request.POST,
**kwargs['formset_kwargs'])
if formset.is_valid():
formset.save()
return create_update.redirect(
kwargs.get('post_save_redirect', None), package)
formset = kwargs['formset_factory'](**kwargs['formset_kwargs'])
kwargs['extra_context']['formset'] = formset
return render_to_response(kwargs['template_name'],
kwargs['extra_context'],
context_instance=RequestContext(request),
mimetype=kwargs['mimetype'])
def manage_metadata(request, package, version, **kwargs):
kwargs.setdefault('template_name', 'djangopypi/release_manage.html')
kwargs.setdefault('template_object_name', 'release')
kwargs.setdefault('extra_context', {})
kwargs.setdefault('mimetype', settings.DEFAULT_CONTENT_TYPE)
release = get_object_or_404(Package, name=package).get_release(version)
if not release:
raise Http404('Version %s does not exist for %s' % (
version,
package,
))
if not release.metadata_version in conf.METADATA_FORMS:
#TODO: Need to change this to a more meaningful error
raise Http404('Metadata Version is not supported')
kwargs['extra_context'][kwargs['template_object_name']] = release
form_class = conf.METADATA_FORMS[release.metadata_version]
if isinstance(form_class, basestring):
app_module, class_name = form_class.rsplit('.', 1)
form_class = getattr(__import__(app_module, {}, {}, [class_name]),
class_name)
conf.METADATA_FORMS[release.metadata_version] = form_class
initial = {}
multivalue = ('classifier', )
for key, values in release.package_info.iterlists():
if key in multivalue:
initial[key] = values
else:
initial[key] = '\n'.join(values)
if request.method == 'POST':
form = form_class(data=request.POST, initial=initial)
if form.is_valid():
for key, value in form.cleaned_data.iteritems():
if isinstance(value, basestring):
release.package_info[key] = value
elif hasattr(value, '__iter__'):
release.package_info.setlist(key, list(value))
release.save()
return create_update.redirect(
kwargs.get('post_save_redirect', None), release)
else:
form = form_class(initial=initial)
kwargs['extra_context']['form'] = form
return render_to_response(kwargs['template_name'],
kwargs['extra_context'],
context_instance=RequestContext(request),
mimetype=kwargs['mimetype'])
def create_message(request,
model=None,
template_name=None,
template_loader=loader,
extra_context=None,
post_save_redirect=None,
login_required=False,
context_processors=None,
form_class=None):
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = create_update.get_model_and_form_class(
model, form_class)
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save()
msg = ugettext("The %(verbose_name)s was created successfully.") %\
{"verbose_name": model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
new_object.sender = request.user
new_object.save()
if new_object.type == DatedMessage.TYPE_U2U:
try:
send_mail(
settings.EMAIL_SUBJECT_PREFIX +
"User %s has sent you a message" % (new_object.sender),
"Original Message:\n\"%s\"\n\n\nYou can check the new message at https://%s/messagecenter/\n\n"
% (new_object.msg_text, settings.SITE_DOMAIN),
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=User.objects.filter(
id__in=request.POST.getlist('users')).values_list(
'email', flat=True),
#recipient_list=[settings.ROOT_EMAIL],
)
except Exception as e:
print "User email notification could no be sent"
return create_update.redirect(post_save_redirect, new_object)
else:
form = form_class()
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label,
model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
}, context_processors)
create_update.apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
def create_object(request, model=None, template_name=None,
template_loader=loader, extra_context=None, post_save_redirect=None,
login_required=False, context_processors=None, form_class=None,
current_user=False, pre_save_signal=None, post_save_signal=None,
signal_kwarg_name='object'):
'''
Generic create_object view with extra functionality:
current_user
update __init__ of the form class to use current user as initial
pre_save_signal
signal to send before save
post_save signal
signal to send after save
'''
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = create_update.get_model_and_form_class(model, form_class)
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save(commit=False)
if current_user:
new_object.user = request.user
signal_kwargs = {
'sender': new_object.__class__,
signal_kwarg_name: new_object,
'request': request
}
# Signal that the object is about to be saved
if pre_save_signal:
pre_save_signal.send(**signal_kwargs)
new_object.save()
form.save_m2m()
# Signal that object was saved
if post_save_signal:
post_save_signal.send(**signal_kwargs)
msg = ugettext("The %(verbose_name)s was created successfully.") %\
{"verbose_name": model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
return create_update.redirect(post_save_redirect, new_object)
else:
form = form_class()
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
}, context_processors)
create_update.apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
def add_campaign(request):
if request.method == 'POST':
form = CampaignForm(request.POST, request.FILES)
if form.is_valid():
campaign = form.save(commit = False)
campaign.organizer = request.user.key()
if (campaign.put()):
return redirect(reverse('myapp.views.show_campaign', kwargs = dict(key = '%(key)s')), campaign)
else:
form = CampaignForm()
return render_to_response(request, 'campaign_form.html', {'form': form})
def manage_metadata(request, package, version, **kwargs):
kwargs.setdefault('template_name', 'djangopypi/release_manage.html')
kwargs.setdefault('template_object_name', 'release')
kwargs.setdefault('extra_context',{})
kwargs.setdefault('mimetype',settings.DEFAULT_CONTENT_TYPE)
release = get_object_or_404(Package, name=package).get_release(version)
if not release:
raise Http404('Version %s does not exist for %s' % (version,
package,))
if not release.metadata_version in conf.METADATA_FORMS:
#TODO: Need to change this to a more meaningful error
raise Http404('Metadata Version is not supported')
kwargs['extra_context'][kwargs['template_object_name']] = release
form_class = conf.METADATA_FORMS[release.metadata_version]
if isinstance(form_class, basestring):
app_module, class_name = form_class.rsplit('.', 1)
form_class = getattr(__import__(app_module, {}, {}, [class_name]), class_name)
conf.METADATA_FORMS[release.metadata_version] = form_class
initial = {}
multivalue = ('classifier',)
for key, values in release.package_info.iterlists():
if key in multivalue:
initial[key] = values
else:
initial[key] = '\n'.join(values)
if request.method == 'POST':
form = form_class(data=request.POST, initial=initial)
if form.is_valid():
for key, value in form.cleaned_data.iteritems():
if isinstance(value, basestring):
release.package_info[key] = value
elif hasattr(value, '__iter__'):
release.package_info.setlist(key, list(value))
release.save()
return create_update.redirect(kwargs.get('post_save_redirect',None),
release)
else:
form = form_class(initial=initial)
kwargs['extra_context']['form'] = form
return render_to_response(kwargs['template_name'], kwargs['extra_context'],
context_instance=RequestContext(request),
mimetype=kwargs['mimetype'])
def create_object(request, spam_check_scope_attr, author_name_attr, model=None, template_name=None,
template_loader=loader, extra_context=None, post_save_redirect=None,
login_required=False, context_processors=None, form_class=None, initial=None, initial_with_get=False):
"""
Generic object-creation function.
Templates: ``<app_label>/<model_name>_form.html``
Context:
form
the form for the object
"""
if not initial and initial_with_get:
initial = request.GET.items()
elif initial_with_get:
initial.update(request.GET.items())
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
if request.method == 'POST':
if issubclass(form_class, ModelFormWithRequest):
form = form_class(request, request.POST, request.FILES)
else:
form = form_class(request.POST, request.FILES)
if form.is_valid():
# checking spam
new_object = form.save(commit=False)
body = getattr(new_object, spam_check_scope_attr, None)
author = getattr(new_object, author_name_attr, None)
if _is_spam(model, new_object, body, author, request):
msg = ugettext("The %(verbose_name)s was created unsuccessfully.") %\
{"verbose_name": model._meta.verbose_name}
messages.error(request, msg, fail_silently=True)
else:
new_object = form.save(commit=True)
msg = ugettext("The %(verbose_name)s was created successfully.") %\
{"verbose_name": model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
return redirect(post_save_redirect, new_object)
else:
if issubclass(form_class, ModelFormWithRequest):
form = form_class(request, initial=initial)
else:
form = form_class(initial=initial)
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
}, context_processors)
apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
def manage_metadata(request, owner, package, version, **kwargs):
kwargs.pop("owner")
kwargs.setdefault("template_name", "userpypi/release_manage.html")
kwargs.setdefault("template_object_name", "release")
kwargs.setdefault("extra_context", {})
kwargs.setdefault("mimetype", settings.DEFAULT_CONTENT_TYPE)
release = get_object_or_404(Package, owner=request.user, name=package).get_release(version)
if not release:
raise Http404("Version %s does not exist for %s" % (version, package))
if not release.metadata_version in METADATA_FORMS:
# TODO: Need to change this to a more meaningful error
raise Http404()
kwargs["extra_context"][kwargs["template_object_name"]] = release
form_class = get_class(METADATA_FORMS.get(release.metadata_version))
initial = {}
multivalue = ("classifier",)
for key, values in release.package_info.iterlists():
if key in multivalue:
initial[key] = values
else:
initial[key] = "\n".join(values)
if request.method == "POST":
form = form_class(data=request.POST, initial=initial)
if form.is_valid():
for key, value in form.cleaned_data.iteritems():
if isinstance(value, basestring):
release.package_info[key] = value
elif hasattr(value, "__iter__"):
release.package_info.setlist(key, list(value))
release.save()
return create_update.redirect(kwargs.get("post_save_redirect", None), release)
else:
form = form_class(initial=initial)
kwargs["extra_context"]["form"] = form
return render_to_response(
kwargs["template_name"],
kwargs["extra_context"],
context_instance=RequestContext(request),
mimetype=kwargs["mimetype"],
)
def update_object(request, model=None, object_id=None, slug=None,
slug_field='slug', template_name=None, template_loader=loader,
extra_context=None, post_save_redirect=None, login_required=False,
context_processors=None, template_object_name='object',
form_class=None, initial=None):
"""
Generic object-update function.
Templates: ``<app_label>/<model_name>_form.html``
Context:
form
the form for the object
object
the original object being edited
"""
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
obj = lookup_object(model, object_id, slug, slug_field)
if request.method == 'POST':
if issubclass(form_class, ModelFormWithRequest):
form = form_class(request, request.POST, request.FILES, instance=obj)
else:
form = form_class(request.POST, request.FILES, instance=obj)
if form.is_valid():
obj = form.save()
msg = ugettext("The %(verbose_name)s was updated successfully.") %\
{"verbose_name": model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
return redirect(post_save_redirect, obj)
else:
if issubclass(form_class, ModelFormWithRequest):
form = form_class(request, instance=obj, initial=initial)
else:
form = form_class(instance=obj, initial=initial)
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
template_object_name: obj,
}, context_processors)
apply_extra_context(extra_context, c)
response = HttpResponse(t.render(c))
populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.attname))
return response
def create_user_owned_object(
request,
model=None,
template_name=None,
extra_context=None,
post_save_redirect=None,
login_required=False,
context_processors=None,
form_class=None,
):
if extra_context is None:
extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
if request.method == "POST":
form = form_class(request.POST, request.FILES)
if form.is_valid():
# ~ new_object = Task()
new_object = form.save(commit=False)
# ~ relation with session user
new_object.owner = request.user
new_object.save()
msg = ugettext("The %(verbose_name)s was created successfully.") % {
"verbose_name": model._meta.verbose_name
}
messages.success(request, msg, fail_silently=True)
return redirect(post_save_redirect, new_object)
else:
form = form_class()
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
return render_to_response(template_name, {"form": form}, RequestContext(request))
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {"form": form, template_object_name: obj}, context_processors)
apply_extra_context(extra_context, c)
response = HttpResponse(t.render(c))
populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.attname))
return response
def create_message(request, model=None, template_name=None,
template_loader=loader, extra_context=None, post_save_redirect=None,
login_required=False, context_processors=None, form_class=None):
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = create_update.get_model_and_form_class(model, form_class)
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save()
msg = ugettext("The %(verbose_name)s was created successfully.") %\
{"verbose_name": model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
new_object.sender = request.user
new_object.save()
if new_object.type == DatedMessage.TYPE_U2U:
try:
send_mail(
settings.EMAIL_SUBJECT_PREFIX + "User %s has sent you a message" % (new_object.sender),
"Original Message:\n\"%s\"\n\n\nYou can check the new message at https://%s/messagecenter/\n\n" % (new_object.msg_text, settings.SITE_DOMAIN),
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list= User.objects.filter(id__in = request.POST.getlist('users')).values_list('email', flat=True),
#recipient_list=[settings.ROOT_EMAIL],
)
except Exception as e:
print "[WARNING] User e-mail notification could not be sent. Details: %s" % str(e)
return create_update.redirect(post_save_redirect, new_object)
else:
form = form_class()
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
}, context_processors)
create_update.apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
def my_create_object(
request,
model=None,
template_name=None,
template_loader=loader,
extra_context=None,
post_save_redirect=None,
login_required=False,
context_processors=None,
form_class=None,
):
"""
Generic object-creation function.
Templates: ``<app_label>/<model_name>_form.html``
Context:
form
the form for the object
"""
model, form_class = get_model_and_form_class(model, form_class)
if request.method == "POST":
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save()
new_object.creator = request.user
new_object.save()
if request.user.is_authenticated():
Message(
user=request.user,
message=ugettext("The %(verbose_name)s was created successfully.")
% {"verbose_name": model._meta.verbose_name},
).put()
return redirect(post_save_redirect, new_object)
else:
form = form_class()
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {"form": form}, context_processors)
return HttpResponse(t.render(c))
def task_update(
request,
model=None,
object_id=None,
slug=None,
slug_field="slug",
template_name=None,
extra_context=None,
post_save_redirect=None,
login_required=False,
context_processors=None,
template_object_name="object",
form_class=None,
):
if extra_context is None:
extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
obj = lookup_object(model, object_id, slug, slug_field)
if request.method == "POST":
# ~ recuperar o crear el proyecto
p = Project.objects.get_or_create_by_owner_and_title(request.user, request.POST.get("project_title"))
form = form_class(request.POST, request.FILES, instance=obj)
del form.fields["project"]
if form.is_valid():
obj = form.save(commit=False)
obj.project = p
obj.save()
msg = ugettext("The %(verbose_name)s was updated successfully.") % {
"verbose_name": model._meta.verbose_name
}
messages.success(request, msg, fail_silently=True)
if "_continue" not in request.POST:
return redirect(post_save_redirect, obj)
else:
form = form_class(instance=obj)
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
return render_to_response(template_name, {"form": form, "object": obj}, RequestContext(request))
def create_object(request, model=None, template_name=None,
template_loader=loader, extra_context=None, post_save_redirect=None,
login_required=False, context_processors=None, form_class=None):
"""
Generic object-creation function.
Templates: ``<app_label>/<model_name>_form.html``
Context:
form
the form for the object
"""
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save()
if request.user.is_authenticated():
request.user.message_set.create(message=ugettext("The %(verbose_name)s was created successfully.") % {"verbose_name": model._meta.verbose_name})
return redirect(post_save_redirect, new_object)
else:
form = form_class()
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
if hasattr(request, 'device'):
d = getattr(request, 'device', {})
t = template_loader.get_template(template_name, d)
else:
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
}, context_processors)
apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
def manage_metadata(request, package_name, version):
release = _get_release(request, package_name, version)
if not release.metadata_version in METADATA_FORMS:
#TODO: Need to change this to a more meaningful error
raise Http404()
form_class = METADATA_FORMS.get(release.metadata_version)
initial = {}
multivalue = ('classifier',)
for key, values in release.package_info.iterlists():
if key in multivalue:
initial[key] = values
else:
initial[key] = '\n'.join(values)
if request.method == 'POST':
form = form_class(data=request.POST, initial=initial)
if form.is_valid():
for key, value in form.cleaned_data.iteritems():
if isinstance(value, basestring):
release.package_info[key] = value
elif hasattr(value, '__iter__'):
release.package_info.setlist(key, list(value))
release.save()
return create_update.redirect(None, release)
else:
form = form_class(initial=initial)
return render_to_response(
'pypi_packages/release_manage.html',
dict(release=release, form=form),
context_instance = RequestContext(request),
mimetype = settings.DEFAULT_CONTENT_TYPE,
)
def create(request,
template_name,
form_class = RepositoryForm,
post_save_redirect = None,
extra_context = {},
template_loader = loader,
context_processors = None,
):
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save()
return redirect(post_save_redirect, new_object)
else:
form = form_class()
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
}, context_processors)
apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
def create_object_related(request, model=None, form_class=None, #foreign_model=None,
foreign_id=0,foreign_model=None, foreign_field_name='',#~ initial={}
extra_context={},template_name=None,post_save_redirect=None, ajax=None):
"""
This view allows you to add an object that belongs to a father model.
In the template you won't view the foreign key field. It will take the
parent id automatically.
"""
from django.views.generic.create_update import get_model_and_form_class
from django.views.generic.create_update import redirect
from django.utils.translation import ugettext
#~ if login_required and not request.user.is_authenticated():
#~ return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
if request.method == 'POST':
if not post_save_redirect:
try:
post_save_redirect=foreign_model.objects.get(pk=foreign_id).get_absolute_url()
except:
pass
form = form_class(request.POST, request.FILES)
del form.fields[foreign_field_name]
if form.is_valid():
new_object = form.save(commit=False)
#~ new_object.contact=foreign_id
setattr(new_object,foreign_field_name+'_id',foreign_id)
new_object.save()
msg = ugettext("The %(verbose_name)s was created successfully.") %\
{"verbose_name": model._meta.verbose_name}
#~ messages.success(request, msg, fail_silently=True)
return redirect(post_save_redirect, new_object)
else:
form = form_class()
del form.fields[foreign_field_name]
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
return render_to_response(template_name, {'foreign_id':foreign_id,'form': form,'opts':model._meta}, context_instance=RequestContext(request))
def create(
request,
template_name,
form_class=RepositoryForm,
post_save_redirect=None,
extra_context={},
template_loader=loader,
context_processors=None,
):
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save()
return redirect(post_save_redirect, new_object)
else:
form = form_class()
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
}, context_processors)
apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
def upload_file(request, package, version, **kwargs):
release = get_object_or_404(Package, name=package).get_release(version)
if not release:
raise Http404("Version %s does not exist for %s" % (version, package))
kwargs.setdefault("form_factory", DistributionUploadForm)
kwargs.setdefault(
"post_save_redirect",
reverse("djangopypi-release-manage-files", kwargs={"package": package, "version": version}),
)
kwargs.setdefault("template_name", "djangopypi/release_upload_file.html")
kwargs.setdefault("template_object_name", "release")
kwargs.setdefault("extra_context", {})
kwargs.setdefault("mimetype", settings.DEFAULT_CONTENT_TYPE)
kwargs["extra_context"][kwargs["template_object_name"]] = release
if request.method == "POST":
form = kwargs["form_factory"](data=request.POST, files=request.FILES)
if form.is_valid():
dist = form.save(commit=False)
dist.release = release
dist.uploader = request.user
dist.save()
return create_update.redirect(kwargs.get("post_save_redirect"), release)
else:
form = kwargs["form_factory"]()
kwargs["extra_context"]["form"] = form
return render_to_response(
kwargs["template_name"],
kwargs["extra_context"],
context_instance=RequestContext(request),
mimetype=kwargs["mimetype"],
)
def upload_file(request, package_name, version):
release = _get_release(request, package_name, version)
if request.method == 'POST':
form = DistributionUploadForm(data=request.POST, files=request.FILES)
if form.is_valid():
dist = form.save(commit=False)
dist.release = release
dist.uploader = request.user
dist.save()
return create_update.redirect(
reverse('djangopypi2-release-manage-files',
kwargs=dict(package_name=package_name, version=version)),
release)
else:
form = DistributionUploadForm()
return render_to_response(
'pypi_packages/release_upload_file.html',
dict(release=release, form=form),
context_instance = RequestContext(request),
mimetype = settings.DEFAULT_CONTENT_TYPE,
)
def create_object(request, model=None, template_name=None,
template_loader=loader, extra_context=None, post_save_redirect=None,
login_required=False, context_processors=None, form_class=None,
inlines=None, initial={}, preprocess_form=lambda _:_):
"""
Generic object-creation function with inlines capability.
Templates: ``<app_label>/<model_name>_form.html``
Context:
form
the form for the object
xxx_formset
ModelFormSet for model classes in ``inlines`` argument.
"""
if extra_context is None:
extra_context = {}
if inlines is None:
inlines = ()
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
formset_classes = []
formsets = []
tmodel, form_class = get_model_and_form_class(model, form_class)
if True or issubclass(form_class, BaseForm):
class InitialModelForm(form_class):
class Meta:
model = tmodel
def __init__(self, *args, **kwargs):
request_initial = dict(request.GET.items())
request_initial.update(initial)
kwargs['initial'] = request_initial#{'field1': request.GET.get('field1','')}
return super(InitialModelForm, self).__init__(*args, **kwargs)
form_class = InitialModelForm
model = tmodel
for inline in inlines:
formset_classes.append(inlineformset_factory(model, **inline))
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
preprocess_form(form)
if form.is_valid():
form_validated = True
new_object = form.save()
else:
form_validated = False
new_object = model()
for klass in formset_classes:
formset = klass(request.POST, request.FILES, instance=new_object)
formsets.append(formset)
if all_valid(formsets) and form_validated:
new_object.save()
for formset in formsets:
formset.save()
if request.user.is_authenticated():
request.user.message_set.create(message=ugettext("The "
"%(verbose_name)s was created successfully.") %
{"verbose_name": model._meta.verbose_name})
return redirect(post_save_redirect, new_object)
else:
form = form_class()
preprocess_form(form)
for klass in formset_classes:
formset = klass()
formsets.append(formset)
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label,
model._meta.object_name.lower())
template = template_loader.get_template(template_name)
context = RequestContext(request, {
'form': form,
}, context_processors)
apply_extra_context(extra_context, context)
for formset in formsets:
key = '%s_formset' % formset.model._meta.object_name.lower()
context[key] = formset
return http.HttpResponse(template.render(context))
def create_object_detail(request, queryset, current_user=True, object_id=None, slug=None,
slug_field='slug', create_model=None, template_name=None, template_name_field=None,
template_loader=loader, extra_context=None, post_save_redirect=None, login_required=False,
context_processors=None, template_object_name='object',
mimetype=None, form_class=None):
"""
Generic detail of an object with create form for other model.
Templates: ``<app_label>/<model_name>_detail_<create_model_name>_form.html``
Context:
object
the object
"""
if extra_context is None: extra_context = {}
if (login_required or current_user) and not request.user.is_authenticated():
return redirect_to_login(request.path)
create_model, form_class = get_model_and_form_class(create_model, form_class)
if current_user:
form_class = get_current_user_form_class(form_class, request.user.id)
# create_object part
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid():
new_object = form.save()
msg = ugettext("The %(verbose_name)s was created successfully.") %\
{"verbose_name": create_model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
return redirect(post_save_redirect, new_object)
else:
form = form_class()
# object_detail part
model = queryset.model
if object_id:
queryset = queryset.filter(pk=object_id)
elif slug and slug_field:
queryset = queryset.filter(**{slug_field: slug})
else:
raise AttributeError("Generic detail view must be called with either an object_id or a slug/slug_field.")
try:
obj = queryset.get()
except ObjectDoesNotExist:
raise Http404("No %s found matching the query" % (model._meta.verbose_name))
# Create the template, context, response
if not template_name:
template_name = "%s/%s_detail_%s_form.html" % (model._meta.app_label, model._meta.object_name.lower(), create_model._meta.object_name.lower())
if template_name_field:
template_name_list = [getattr(obj, template_name_field), template_name]
t = template_loader.select_template(template_name_list)
else:
t = template_loader.get_template(template_name)
c = RequestContext(request, {
template_object_name: obj,
'form': form,
}, context_processors)
apply_extra_context(extra_context, c)
response = HttpResponse(t.render(c), mimetype=mimetype)
populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.name))
return response
def update_object(request, model=None, object_id=None, slug=None,
slug_field='slug', template_name=None, template_loader=loader,
extra_context=None, post_save_redirect=None, login_required=False,
context_processors=None, template_object_name='object',
form_class=None, inlines=None):
"""
Generic object-update function with inlines.
Templates: ``<app_label>/<model_name>_form.html``
Context:
form
the form for the object
object
the original object being edited
xxx_formset
ModelFormSet for model classes in ``inlines`` argument.
"""
if extra_context is None:
extra_context = {}
if inlines is None:
inlines = ()
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
formset_classes = []
formsets = []
model, form_class = get_model_and_form_class(model, form_class)
obj = lookup_object(model, object_id, slug, slug_field)
for inline in inlines:
formset_classes.append(inlineformset_factory(model, **inline))
if request.method == 'POST':
form = form_class(request.POST, request.FILES, instance=obj)
if form.is_valid():
form_validated = True
new_object = form.save()
else:
form_validated = False
new_object = obj
for klass in formset_classes:
formset = klass(request.POST, request.FILES, instance=new_object)
formsets.append(formset)
if all_valid(formsets) and form_validated:
new_object.save()
for formset in formsets:
formset.save()
if request.user.is_authenticated():
request.user.message_set.create(message=ugettext("The "
"%(verbose_name)s was updated successfully.") %
{"verbose_name": model._meta.verbose_name})
return redirect(post_save_redirect, new_object)
else:
form = form_class(instance=obj)
for klass in formset_classes:
formset = klass(instance=obj)
formsets.append(formset)
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label,
model._meta.object_name.lower())
template = template_loader.get_template(template_name)
context = RequestContext(request, {
'form': form,
template_object_name: obj,
}, context_processors)
apply_extra_context(extra_context, context)
for formset in formsets:
key = '%s_formset' % formset.model._meta.object_name.lower()
context[key] = formset
response = http.HttpResponse(template.render(context))
populate_xheaders(request, response, model, getattr(obj,
obj._meta.pk.name))
return response
def create_update_object(request, model=None, object_id=None,template_name=None,
template_loader=loader, extra_context=None, post_save_redirect=None,
login_required=False, context_processors=None, form_class=None ,
formset_class=None, initial_form={}, initial_formset={}):
"""
Custom generic object-creation function.
Templates: ``<app_label>/<model_name>_form.html``
Context:
form
the form for the object
"""
# TODO: Better this generic create_object
if extra_context is None: extra_context = {}
if login_required and not request.user.is_authenticated():
return redirect_to_login(request.path)
model, form_class = get_model_and_form_class(model, form_class)
formset = formset_class
try:
instance=model.objects.get(id=object_id)
except:
instance=False
if request.method == 'POST':
form = form_class(request.POST, request.FILES)
if form.is_valid() and not formset_class:
if instance:
form=form_class(request.POST, request.FILES, instance=instance)
new_object = form.save()
msg = ugettext("The %(verbose_name)s was created successfully.") %\
{"verbose_name": model._meta.verbose_name}
messages.success(request, msg, fail_silently=True)
return redirect(post_save_redirect, new_object)
else:
formset = formset_class(request.POST, request.FILES)
if instance:
form = form_class(request.POST,request.FILES, instance=instance)
if formset.is_valid() and form.is_valid():
new_object=form.save()
form_opts=new_object._meta
obj=formset.save(commit=False)
if hasattr(form_opts,'module_name') and hasattr(obj,form_opts.module_name+'_fk_id'):
setattr(obj,form_opts.module_name+'_fk',new_object)
else:
raise Exception('Error the model %s must has a ForeignKey named %s_fk' % (obj._meta.module_name, form_opts.module_name) )
msg = ugettext("The %s was created successfully.") % model._meta.verbose_name
messages.success(request, msg, fail_silently=True)
formset.save()
return redirect(post_save_redirect, new_object)
else:
form = form_class(**initial_form)
if formset_class:
formset = formset_class(**initial_formset)
# Create the template, context, response
if not template_name:
template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower())
t = template_loader.get_template(template_name)
c = RequestContext(request, {
'form': form,
'formset':formset
}, context_processors)
apply_extra_context(extra_context, c)
return HttpResponse(t.render(c))
