Here are the examples of the python api django.shortcuts.render_to_response taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
164 Examples
0
Example 1
Project: hubplus Source File: views.py
def profile(request, username, template_name="profiles/profile.html"):
#trellis.callInEventLoop(hello, "Tom")
is_me = False
user = request.user
if request.user.is_authenticated() :
if user.username == username :
is_me = True
else :
user = get_anon_user()
other_user = secure_wrap(get_object_or_404(User, username=username),user)
is_following = Following.objects.is_following(request.user, other_user.get_inner())
p = other_user.get_inner().get_profile()
profile = secure_wrap(p,user)
profile.user # trigger permission exception if no access
can_change_avatar = False
try :
profile.change_avatar
can_change_avatar = True
except PlusPermissionsNoAccessException :
pass
interests = get_tags(tagged=other_user.get_inner().get_profile(),
tagged_for=other_user.get_inner(), tag_type='interest')
skills = get_tags(tagged = other_user.get_inner().get_profile(),
tagged_for=other_user.get_inner(), tag_type='skill')
needs = get_tags(tagged = other_user.get_inner().get_profile(),
tagged_for=other_user.get_inner(), tag_type='need')
user_type = ContentType.objects.get_for_model(other_user)
# new style statuses
tweets = FeedItem.feed_manager.get_from(other_user.get_inner()).order_by("-sent")
if tweets :
latest_status = tweets[0]
status_since = defaultfilters.timesince(latest_status.sent)
else:
status_since = ''
status_type = 'profile'
try:
profile.get_all_sliders
perms_bool = True
except PlusPermissionsNoAccessException:
perms_bool = False
profile = TemplateSecureWrapper(profile)
search_type = 'profile_list'
search_types = narrow_search_types()
search_types_len = len(search_types)
search_type_label = search_types[0][1][2]
host_info = p.get_host_info()
host_info = secure_wrap(host_info, user, interface_names=['Viewer', 'Editor'])
see_host_info = False
try :
host_info.user
see_host_info = True
except :
pass # can't see host_info
host_info = TemplateSecureWrapper(host_info)
hubs = other_user.get_inner().hubs()
non_hub_groups = [(g.group_app_label() + ':group', g) for g in
other_user.get_inner().groups.filter(level='member').exclude(id__in=hubs)]
hubs = [(g.group_app_label() + ':group', g) for g in hubs]
see_about = is_me or show_section(profile, ('about',))
see_contacts = is_me or show_section(profile,('mobile','home','work','fax','website','address','email_address'))
see_links = is_me
links = get_links_for(other_user,RequestContext(request))
if links :
see_links = True
can_tag = profile.has_interface('Profile.Editor')
template_args = {
"is_me": is_me,
"is_following": is_following,
"other_user": other_user.get_inner(), # XXX - should fix this get_inner
"profile":profile,
"can_change_avatar":can_change_avatar,
"head_title" : "%s" % profile.get_display_name(),
"status_type" : status_type,
"status_since" : status_since,
"host_info" : host_info,
"skills" : skills,
"needs" : needs,
"interests" : interests,
"other_user_tweets" : tweets,
"permissions":perms_bool,
"non_hub_groups":non_hub_groups,
"hubs":hubs,
"search_type":search_type,
"search_types":search_types,
"search_type_label":search_type_label,
"search_types_len":search_types_len,
"host_info":host_info,
"see_host_info":see_host_info,
"see_about":see_about,
"see_contacts":see_contacts,
"see_links":see_links,
"other_user_class":user_type.id,
"other_user_id":other_user.id,
"can_tag":can_tag,
}
labels = {'MAIN_HUB_LABEL':_('Main %s')%settings.HUB_NAME,
'MAIN_HUB_DEFAULT':_("No %s selected")%settings.HUB_NAME}
template_args.update(labels)
return render_to_response(template_name, template_args, context_instance=RequestContext(request))
0
Example 2
Project: zorna Source File: views.py
def edit_calendar_reccurrent_event(request, event_id, event, occurrence):
instance_event_details = EventDetails.objects.get_eventdetails_for_object(
event)
calendars = get_user_calendars(request.user, ['manager', 'creator'])
if event.calendar.pk not in [c.calendar_id for c in calendars]:
return HttpResponseRedirect(reverse('view_calendar', args=[]))
original_start = event.start
params = event.rule.get_params()
initial_data = {}
initial_data['rule'] = event.rule.frequency
if 'interval' in params:
initial_data['interval'] = params['interval']
if 'byweekday' in params:
initial_data['weekdays'] = params['byweekday'] if type(params[
'byweekday']) == type(list()) else [params['byweekday']]
initial_data['start'] = occurrence.start
initial_data['end'] = occurrence.end
initial_data['title'] = occurrence.title
initial_data['description'] = occurrence.description
if request.method == 'POST':
form = EditEventForm(data=request.POST, instance=event)
form_details = EditEventDetailsForm(
data=request.POST, instance=instance_event_details)
action = request.POST.get('action', None)
if action and action == 'deleteone':
occurrence.cancel()
return HttpResponseRedirect(reverse('view_calendar', args=[]))
if action and action == 'deleteall':
persisted_occurrences = event.occurrence_set.all()
for occ in persisted_occurrences:
try:
EventDetails.objects.get_eventdetails_for_object(
occ).delete()
except:
pass
event.rule.delete()
event.delete()
instance_event_details.delete()
return HttpResponseRedirect(reverse('view_calendar', args=[]))
if action and action == 'updateevent' and form.is_valid(): # update only this occurrence
occurrence.title = form.cleaned_data['title']
occurrence.description = form.cleaned_data['description']
occurrence.start = form.cleaned_data[
'start'].strftime('%Y-%m-%d %H:%M:%S')
occurrence.end = form.cleaned_data[
'end'].strftime('%Y-%m-%d %H:%M:%S')
occurrence.save()
EventDetails.objects.create_details(
occurrence,
request.POST.get('location', ''),
request.POST.get('free_busy', 0),
request.POST.get('privacy', 0),
)
return HttpResponseRedirect(reverse('view_calendar', args=[]))
if form.is_valid():
calendar = get_object_or_404(
ZornaCalendar, pk=request.POST['calendar_id'])
evt = form.save(commit=False)
evt.calendar = calendar.calendar
if 'end_recurring_period' in form.cleaned_data and form.cleaned_data['end_recurring_period']:
evt.end_recurring_period = evt.end_recurring_period + \
datetime.timedelta(days=1, seconds= -1)
rule = event.rule
if rule and request.POST['rule'] == '':
persisted_occurrences = event.occurrence_set.all()
for occ in persisted_occurrences:
try:
EventDetails.objects.get_eventdetails_for_object(
occ).delete()
except:
pass
event.rule = None
rule.delete()
if request.POST['rule'] != '':
params = "interval:" + request.POST['interval']
if request.POST['rule'] == 'WEEKLY':
wl = request.POST.getlist('weekdays')
if not wl:
wl = [str((int(evt.start.strftime('%w')) + 6) % 7)]
if wl:
params += ";byweekday:" + ",".join(wl)
if evt.rule:
evt.rule.name = request.POST['rule']
evt.rule.frequency = request.POST['rule']
evt.rule.params = params
evt.rule.save()
else:
rule = Rule(name=request.POST['rule'],
frequency=request.POST['rule'],
params=params
)
rule.save()
evt.rule = rule
if occurrence.start.date() == evt.start.date():
td = evt.end.date() - evt.start.date()
evt.start = datetime.datetime.combine(
original_start.date(), evt.start.time())
evt.end = datetime.datetime.combine(
original_start.date() + td, evt.end.time())
evt.save()
form_details.save()
return HttpResponseRedirect(reverse('view_calendar', args=[]))
else:
form = EditEventForm(data=request.POST)
form_details = EditEventDetailsForm(data=request.POST)
else:
form = EditEventForm(instance=event, initial=initial_data)
form_details = EditEventDetailsForm(instance=instance_event_details)
extra_context = {
'form': form,
'boccurrence': False,
'event': event,
'form_details': form_details,
'calendars': calendars,
'calendar': ZornaCalendar.objects.get(calendar=event.calendar)
}
context = RequestContext(request)
return render_to_response('calendars/calendar_edit.html', extra_context, context_instance=context)
0
Example 3
Project: django-adminactions Source File: merge.py
def merge(modeladmin, request, queryset): # noqa
"""
Merge two model instances. Move all foreign keys.
"""
opts = modeladmin.model._meta
perm = "{0}.{1}".format(opts.app_label, get_permission_codename('adminactions_merge', opts))
if not request.user.has_perm(perm):
messages.error(request, _('Sorry you do not have rights to execute this action'))
return
def raw_widget(field, **kwargs):
""" force all fields as not required"""
kwargs['widget'] = TextInput({'class': 'raw-value'})
return field.formfield(**kwargs)
merge_form = getattr(modeladmin, 'merge_form', MergeForm)
MForm = modelform_factory(modeladmin.model,
form=merge_form,
exclude=('pk', ),
formfield_callback=raw_widget)
OForm = modelform_factory(modeladmin.model,
exclude=('pk', ),
formfield_callback=raw_widget)
tpl = 'adminactions/merge.html'
# transaction_supported = model_supports_transactions(modeladmin.model)
ctx = {
'_selected_action': request.POST.getlist(helpers.ACTION_CHECKBOX_NAME),
'transaction_supported': 'Un',
'select_across': request.POST.get('select_across') == '1',
'action': request.POST.get('action'),
'fields': [f for f in queryset.model._meta.fields if not f.primary_key and f.editable],
'app_label': queryset.model._meta.app_label,
'result': '',
'opts': queryset.model._meta}
if 'preview' in request.POST:
master = queryset.get(pk=request.POST.get('master_pk'))
original = clone_instance(master)
other = queryset.get(pk=request.POST.get('other_pk'))
formset = formset_factory(OForm)(initial=[model_to_dict(master), model_to_dict(other)])
with transaction.nocommit():
form = MForm(request.POST, instance=master)
other.delete()
form_is_valid = form.is_valid()
if form_is_valid:
ctx.update({'original': original})
tpl = 'adminactions/merge_preview.html'
else:
master = queryset.get(pk=request.POST.get('master_pk'))
other = queryset.get(pk=request.POST.get('other_pk'))
elif 'apply' in request.POST:
master = queryset.get(pk=request.POST.get('master_pk'))
other = queryset.get(pk=request.POST.get('other_pk'))
formset = formset_factory(OForm)(initial=[model_to_dict(master), model_to_dict(other)])
with transaction.nocommit():
form = MForm(request.POST, instance=master)
stored_pk = other.pk
other.delete()
ok = form.is_valid()
other.pk = stored_pk
if ok:
if form.cleaned_data['dependencies'] == MergeForm.DEP_MOVE:
related = api.ALL_FIELDS
else:
related = None
fields = form.cleaned_data['field_names']
api.merge(master, other, fields=fields, commit=True, related=related)
return HttpResponseRedirect(request.path)
else:
messages.error(request, form.errors)
else:
try:
master, other = queryset.all()
# django 1.4 need to remove the trailing milliseconds
for field in master._meta.fields:
if isinstance(field, models.DateTimeField):
for target in (master, other):
raw_value = getattr(target, field.name)
if raw_value:
fixed_value = datetime(
raw_value.year,
raw_value.month,
raw_value.day,
raw_value.hour,
raw_value.minute,
raw_value.second)
setattr(target, field.name, fixed_value)
except ValueError:
messages.error(request, _('Please select exactly 2 records'))
return
initial = {'_selected_action': request.POST.getlist(helpers.ACTION_CHECKBOX_NAME),
'select_across': 0,
'generic': MergeForm.GEN_IGNORE,
'dependencies': MergeForm.DEP_MOVE,
'action': 'merge',
'master_pk': master.pk,
'other_pk': other.pk}
formset = formset_factory(OForm)(initial=[model_to_dict(master), model_to_dict(other)])
form = MForm(initial=initial, instance=master)
adminForm = helpers.AdminForm(form, modeladmin.get_fieldsets(request), {}, [], model_admin=modeladmin)
media = modeladmin.media + adminForm.media
ctx.update({'adminform': adminForm,
'formset': formset,
'media': mark_safe(media),
'action_short_description': merge.short_description,
'title': u"%s (%s)" % (
merge.short_description.capitalize(),
smart_text(modeladmin.opts.verbose_name_plural),
),
'master': master,
'other': other})
if django.VERSION[:2] > (1, 7):
ctx.update(modeladmin.admin_site.each_context(request))
else:
ctx.update(modeladmin.admin_site.each_context())
if django.VERSION[:2] > (1, 8):
return render(request, tpl, context=ctx)
else:
return render_to_response(tpl, RequestContext(request, ctx))
0
Example 4
Project: tendenci Source File: views.py
@login_required
def template_view(request, template_id, render=True):
"""
Generate newsletter preview
Combine template with context passed via GET
"""
template = get_object_or_404(NewsletterTemplate, template_id=template_id)
if not template.html_file:
raise Http404
if not has_perm(request.user, 'newsletters.view_newslettertemplate'):
raise Http403
simplified = True
login_content = ""
include_login = int(request.GET.get('include_login', 0))
if include_login:
login_content = render_to_string('newsletters/login.txt',
context_instance=RequestContext(request))
jumplink_content = ""
jump_links = int(request.GET.get('jump_links', 1))
if jump_links:
jumplink_content = render_to_string('newsletters/jumplinks.txt', locals(),
context_instance=RequestContext(request))
art_content = ""
articles = int(request.GET.get('articles', 1))
articles_days = request.GET.get('articles_days', 60)
if articles:
articles_list, articles_content = newsletter_articles_list(request, articles_days, simplified)
else:
articles_list = []
articles_content = []
news_content = ""
news = int(request.GET.get('news', 1))
news_days = request.GET.get('news_days',30)
if news:
news_list, news_content = newsletter_news_list(request, news_days, simplified)
else:
news_list = []
news_content = []
jobs_content = ""
jobs = int(request.GET.get('jobs', 1))
jobs_days = request.GET.get('jobs_days', 30)
if jobs:
jobs_list, jobs_content = newsletter_jobs_list(request, jobs_days, simplified)
else:
jobs_list = []
jobs_content = []
pages_content = ""
pages = int(request.GET.get('pages', 0))
pages_days = request.GET.get('pages_days', 7)
if pages:
pages_list, pages_content = newsletter_pages_list(request, pages_days, simplified)
else:
pages_list = []
pages_content = []
directories_content = ""
directories = int(request.GET.get('directories', 0))
directories_days = request.GET.get('directories_days', 7)
if directories:
directories_list, directories_content = newsletter_directories_list(request, directories_days, simplified)
else:
directories_list = []
directories_content = []
resumes_content = ""
resumes = int(request.GET.get('resumes', 0))
resumes_days = request.GET.get('resumes_days', 7)
if resumes:
resumes_list, resumes_content = newsletter_resumes_list(request, resumes_days, simplified)
else:
resumes_list = []
resumes_content = []
try:
events = int(request.GET.get('events', 1))
events_type = request.GET.get('events_type')
start_y, start_m, start_d = request.GET.get('event_start_dt', str(datetime.date.today())).split('-')
event_start_dt = datetime.date(int(start_y), int(start_m), int(start_d))
end_y, end_m, end_d = request.GET.get(
'event_end_dt',
str(datetime.date.today() + datetime.timedelta(days=90))).split('-')
event_end_dt = datetime.date(int(end_y), int(end_m), int(end_d))
events_list, events_content = newsletter_events_list(
request,
start_dt=event_start_dt,
end_dt=event_end_dt,
simplified=simplified)
except ImportError:
events_list = []
events_type = None
text = DTemplate(apply_template_media(template))
context = RequestContext(request,
{
'jumplink_content':jumplink_content,
'login_content':login_content,
"art_content":articles_content, # legacy usage in templates
"articles_content":articles_content,
"articles_list":articles_list,
"jobs_content":jobs_content,
"jobs_list":jobs_list,
"news_content":news_content,
"news_list":news_list,
"pages_content":pages_content,
"pages_list":pages_content,
"directories_content":directories_content,
"directories_list":directories_list,
"resumes_content":resumes_content,
"resumes_list":resumes_list,
"events":events_list, # legacy usage in templates
"events_content":events_content,
"events_list":events_list,
"events_type":events_type
})
content = text.render(context)
if render:
response = HttpResponse(content)
return response
else:
template_name="newsletters/content.html"
return render_to_response(
template_name, {
'content': content,
'template': template},
context_instance=RequestContext(request))
0
Example 5
Project: coursys Source File: view_instructors.py
@requires_role('PLAN')
def view_instructors(request, semester, plan_slug, planned_offering_slug):
semester_plan = get_object_or_404(SemesterPlan, semester__name=semester, slug=plan_slug)
planned_offering = get_object_or_404(PlannedOffering, slug=planned_offering_slug)
all_instructors = Person.objects.filter(role__role__in=["FAC", "SESS", "COOP"], role__unit=semester_plan.unit)
capable_instructors = all_instructors.filter(teachingcapability__course__plannedoffering=planned_offering)
all_instructors = all_instructors.exclude(teachingcapability__course__plannedoffering=planned_offering)
if request.method == 'POST':
semester_plan = get_object_or_404(SemesterPlan, semester__name=semester, slug=plan_slug)
course = get_object_or_404(PlannedOffering, slug=planned_offering_slug, plan=semester_plan)
no_intention_note = "Added by planned administrator. Instructor posted no previous semester teaching intentions."
instructor_id = request.POST['instructor']
if instructor_id == "None":
pre_instructor = course.instructor
course.instructor = None
course.save()
offering_section = course.section[0:2]
labs = PlannedOffering.objects.filter(plan=semester_plan, course=course.course, component__in=['LAB', 'TUT'], section__startswith=offering_section)
for lab in labs:
lab.instructor = None
lab.save()
pre_intention_count = PlannedOffering.objects.filter(plan=semester_plan, instructor=pre_instructor).count()
pre_teaching_intention = TeachingIntention.objects.get(semester=semester_plan.semester, instructor=pre_instructor)
if pre_teaching_intention.note == no_intention_note:
pre_teaching_intention.delete()
else:
pre_teaching_intention.intentionfull = (pre_intention_count >= pre_teaching_intention.count)
pre_teaching_intention.save()
messages.add_message(request, messages.SUCCESS, 'Instructor removed successfully.')
return HttpResponseRedirect(reverse(update_plan, kwargs={'semester': semester_plan.semester.name, 'plan_slug': semester_plan.slug}))
#instructor_id is not None
assigned_instructor = get_object_or_404(Person, userid=instructor_id)
if course.instructor:
pre_instructor = course.instructor
else:
pre_instructor = None
course.instructor = assigned_instructor
course.save()
offering_section = course.section[0:2]
labs = PlannedOffering.objects.filter(plan=semester_plan, course=course.course, component__in=['LAB', 'TUT'], section__startswith=offering_section)
for lab in labs:
lab.instructor = assigned_instructor
lab.save()
if pre_instructor != None:
pre_intention_count = PlannedOffering.objects.filter(plan=semester_plan, instructor=pre_instructor).count()
pre_teaching_intention = TeachingIntention.objects.get(semester=semester_plan.semester, instructor=pre_instructor)
if pre_teaching_intention.note == no_intention_note:
pre_teaching_intention.delete()
else:
pre_teaching_intention.intentionfull = (pre_intention_count >= pre_teaching_intention.count)
pre_teaching_intention.save()
intention_count = PlannedOffering.objects.filter(plan=semester_plan, instructor=assigned_instructor).count()
if TeachingIntention.objects.filter(semester=semester_plan.semester, instructor=assigned_instructor):
teaching_intentions = TeachingIntention.objects.filter(semester=semester_plan.semester, instructor=assigned_instructor)
teaching_intention = teaching_intentions[0]
teaching_intention.intentionfull = (intention_count >= teaching_intentions.count)
teaching_intention.save()
messages.add_message(request, messages.SUCCESS, 'Instructor assinged successfully.')
return HttpResponseRedirect(reverse(update_plan, kwargs={'semester': semester_plan.semester.name, 'plan_slug': semester_plan.slug}))
else:
add_intention = TeachingIntention(instructor=assigned_instructor, semester=semester_plan.semester, count=1, intentionfull=True, note=no_intention_note)
add_intention.save()
messages.add_message(request, messages.WARNING, 'There is no intention for this instructor.')
return HttpResponseRedirect(reverse(update_plan, kwargs={'semester': semester_plan.semester.name, 'plan_slug': semester_plan.slug}))
capable_instructors_list = []
for i in capable_instructors:
capable_instructors_list.append({
'instructor': i,
'intention': TeachingIntention.objects.filter(instructor=i).order_by('semester'),
'teachable': TeachingCapability.objects.filter(instructor=i).order_by('course'),
'current_courses': PlannedOffering.objects.filter(plan=semester_plan, instructor=i, component="LEC")
})
all_instructors_list = []
for i in all_instructors:
all_instructors_list.append({
'instructor': i,
'intention': TeachingIntention.objects.filter(instructor=i).order_by('semester'),
'teachable': TeachingCapability.objects.filter(instructor=i).order_by('course'),
'current_courses': PlannedOffering.objects.filter(plan=semester_plan, instructor=i, component="LEC")
})
return render_to_response("planning/view_instructors.html", {'semester_plan': semester_plan, 'capable_instructors_list': capable_instructors_list, 'all_instructors_list': all_instructors_list, 'planned_offering': planned_offering}, context_instance=RequestContext(request))
0
Example 6
Project: django-facebookconnect Source File: views.py
def setup(request,redirect_url=None,
registration_form_class=FacebookUserCreationForm,
template_name='facebook/setup.html',
extra_context=None):
"""
setup
===============================
Handles a new facebook user. There are three ways to setup a new facebook user.
1. Link the facebook account with an existing django account.
2. Create a dummy django account to attach to facebook. The user must always use
facebook to login.
3. Ask the user to create a new django account
The built in template presents the user with all three options. Once setup is
complete the user will get redirected. The url used in the following order of
presidence:
1. whatever url is in the 'next' get parameter passed to the setup url
2. whatever url is passed to the setup view when the url is defined
3. whatever url is defined in the LOGIN_REDIRECT_URL setting directive
If you define a url to use this view, you can pass the following parameters:
* redirect_url: Defines where to send the user after they are setup. This
can get overridden by the url in the 'next' get param passed on
the url.
* registration_form_class: Django form class to use for new user way #3 explained
above. The form should create a new user.
* template_name: Template to use. Uses 'facebook/setup.html' by default.
* extra_context: A context object whose contents will be passed to the template.
"""
log.debug('in setup view')
#you need to be logged into facebook.
if not request.facebook.uid:
log.debug('Need to be logged into facebook')
url = reverse(facebook_login)
if request.REQUEST.get(REDIRECT_FIELD_NAME,False):
url += "?%s=%s" % (REDIRECT_FIELD_NAME, request.REQUEST[REDIRECT_FIELD_NAME])
return HttpResponseRedirect(url)
#setup forms
login_form = AuthenticationForm()
registration_form = registration_form_class()
#figure out where to go after setup
if request.REQUEST.get(REDIRECT_FIELD_NAME,False):
redirect_url = request.REQUEST[REDIRECT_FIELD_NAME]
elif redirect_url is None:
redirect_url = getattr(settings, "LOGIN_REDIRECT_URL", "/")
#check that this fb user is not already in the system
try:
FacebookProfile.objects.get(facebook_id=request.facebook.uid)
# already setup, move along please
return HttpResponseRedirect(redirect_url)
except FacebookProfile.DoesNotExist, e:
# not in the db, ok to continue
pass
#user submitted a form - which one?
if request.method == "POST":
log.debug('Submitted form')
#lets setup a facebook only account. The user will have to use
#facebook to login.
if request.POST.get('facebook_only',False):
log.debug('Facebook Only')
profile = FacebookProfile(facebook_id=request.facebook.uid)
user = User(username=request.facebook.uid,
email=profile.email)
user.set_unusable_password()
user.save()
profile.user = user
profile.save()
log.info("Added user and profile for %s!" % request.facebook.uid)
user = authenticate(request=request)
login(request, user)
return HttpResponseRedirect(redirect_url)
# user setup his/her own local account in addition to their facebook
# account. The user will have to login with facebook unless they
# reset their password.
elif request.POST.get('register',False):
log.debug('Register a new account')
profile = FacebookProfile(facebook_id=request.facebook.uid)
if profile.first_name != "(Private)":
fname = profile.first_name
if profile.last_name != "(Private)":
lname = profile.last_name
user = User(first_name=fname, last_name=lname)
registration_form = registration_form_class(
data=request.POST, instance=user)
if registration_form.is_valid():
user = registration_form.save()
profile.user = user
profile.save()
log.info("Added user and profile for %s!" % request.facebook.uid)
login(request, authenticate(request=request))
return HttpResponseRedirect(redirect_url)
else:
request.user = User()
request.user.facebook_profile = FacebookProfile(facebook_id=request.facebook.uid)
#user logs in in with an existing account, and the two are linked.
elif request.POST.get('login',False):
login_form = AuthenticationForm(data=request.POST)
if login_form.is_valid():
user = login_form.get_user()
log.debug("Trying to setup FB: %s, %s" % (user,request.facebook.uid))
if user and user.is_active:
FacebookProfile.objects.get_or_create(user=user, facebook_id=request.facebook.uid)
log.info("Attached facebook profile %s to user %s!" % (request.facebook.uid, user))
login(request, user)
return HttpResponseRedirect(redirect_url)
else:
request.user = User()
request.user.facebook_profile = FacebookProfile(facebook_id=request.facebook.uid)
#user didn't submit a form, but is logged in already. We'll just link up their facebook
#account automatically.
elif request.user.is_authenticated():
log.debug('Already logged in')
try:
request.user.facebook_profile
except FacebookProfile.DoesNotExist:
profile = FacebookProfile(facebook_id=request.facebook.uid)
profile.user = request.user
profile.save()
log.info("Attached facebook profile %s to user %s!" % (profile.facebook_id,profile.user))
return HttpResponseRedirect(redirect_url)
# user just showed up
else:
log.debug('Setting up form...')
request.user.facebook_profile = profile = FacebookProfile(facebook_id=request.facebook.uid)
login_form = AuthenticationForm(request)
log.debug('creating a dummy user')
fname = lname = ''
if profile.first_name != "(Private)":
fname = profile.first_name
if profile.last_name != "(Private)":
lname = profile.last_name
user = User(first_name=fname, last_name=lname)
registration_form = registration_form_class(instance=user)
log.debug('going all the way...')
# add the extra_context to this one
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
template_dict = {
"login_form":login_form,
"registration_form":registration_form
}
# we only need to set next if its been passed in the querystring or post vars
if request.REQUEST.get(REDIRECT_FIELD_NAME, False):
template_dict.update( {REDIRECT_FIELD_NAME: request.REQUEST[REDIRECT_FIELD_NAME]})
return render_to_response(
template_name,
template_dict,
context_instance=context)
0
Example 7
Project: foodnetwork Source File: views.py
@login_required
def new_process(request, process_type_id):
try:
foodnet = food_network()
except FoodNetwork.DoesNotExist:
return render_to_response('distribution/network_error.html')
process_manager = get_producer(request)
weekstart = next_delivery_date()
weekend = weekstart + datetime.timedelta(days=5)
expired_date = weekstart + datetime.timedelta(days=5)
pt = get_object_or_404(ProcessType, id=process_type_id)
input_types = pt.input_type.stockable_children()
input_select_form = None
input_create_form = None
input_lot_qties = []
if pt.use_existing_input_lot:
input_lots = InventoryItem.objects.filter(
product__in=input_types,
inventory_date__lte=weekend,
expiration_date__gte=expired_date,
remaining__gt=Decimal("0"))
initial_data = {"quantity": Decimal("0")}
for lot in input_lots:
input_lot_qties.append([lot.id, float(lot.avail_qty())])
if input_lots:
initial_data = {"quantity": input_lots[0].remaining,}
input_select_form = InputLotSelectionForm(input_lots, data=request.POST or None, prefix="inputselection", initial=initial_data)
else:
input_create_form = InputLotCreationForm(input_types, data=request.POST or None, prefix="inputcreation")
# todo: default service provider to process_manager?
service_label = "Processing Service"
service_formset = None
steps = pt.number_of_processing_steps
if steps > 1:
service_label = "Processing Services"
ServiceFormSet = formset_factory(ProcessServiceForm, extra=0)
initial_data = []
for x in range(steps):
initial_data.append({"from_whom": process_manager.id})
print "initial_data", initial_data
service_formset = ServiceFormSet(
data=request.POST or None,
prefix="service",
initial=initial_data,
)
output_types = pt.output_type.stockable_children()
output_label = "Output Lot"
output_formset = None
outputs = pt.number_of_output_lots
if outputs > 1:
output_label = "Output Lots"
OutputFormSet = formset_factory(OutputLotCreationFormsetForm, extra=outputs)
output_formset = OutputFormSet(data=request.POST or None, prefix="output")
for form in output_formset.forms:
form.fields['product'].choices = [(prod.id, prod.long_name) for prod in output_types]
process = None
if request.method == "POST":
#import pdb; pdb.set_trace()
if input_create_form:
if input_create_form.is_valid():
data = input_create_form.cleaned_data
lot = input_create_form.save(commit=False)
producer = data["producer"]
qty = data["planned"]
process = Process(
process_type = pt,
process_date = weekstart,
managed_by = process_manager,
)
process.save()
lot.inventory_date = weekstart
lot.remaining = qty
lot.save()
issue = InventoryTransaction(
transaction_type = "Issue",
process = process,
# todo: is to_whom correct in all these process tx?
from_whom = producer,
to_whom = producer,
inventory_item = lot,
transaction_date = weekstart,
amount = qty)
issue.save()
elif input_select_form:
if input_select_form.is_valid():
data = input_select_form.cleaned_data
lot_id = data['lot']
lot = InventoryItem.objects.get(id=lot_id)
producer = lot.producer
qty = data["quantity"]
process = Process(
process_type = pt,
process_date = weekstart,
managed_by = process_manager,
)
process.save()
issue = InventoryTransaction(
transaction_type = "Issue",
process = process,
from_whom = producer,
to_whom = producer,
inventory_item = lot,
transaction_date = weekstart,
amount = qty)
issue.save()
if process:
if service_formset:
# todo: shd be selective, or not?
if service_formset.is_valid():
for service_form in service_formset.forms:
tx = service_form.save(commit=False)
tx.to_whom = foodnet
tx.process = process
tx.transaction_date = weekstart
tx.save()
#import pdb; pdb.set_trace()
if output_formset:
for form in output_formset.forms:
if form.is_valid():
data = form.cleaned_data
qty = data["planned"]
if qty:
lot = form.save(commit=False)
producer = data["producer"]
lot.inventory_date = weekstart
lot.save()
tx = InventoryTransaction(
transaction_type = "Production",
process = process,
from_whom = producer,
to_whom = producer,
inventory_item = lot,
transaction_date = weekstart,
amount = qty)
tx.save()
return HttpResponseRedirect('/%s/%s/'
% ('producer/process', process.id))
return render_to_response('distribution/new_process.html', {
'input_lot_qties': input_lot_qties,
'input_select_form': input_select_form,
'input_create_form': input_create_form,
'service_formset': service_formset,
'service_label': service_label,
'output_formset': output_formset,
'output_label': output_label,
'tabnav': "producer/producer_tabnav.html",
}, context_instance=RequestContext(request))
0
Example 8
Project: virtmgr Source File: views.py
def pool(request, host_id, pool):
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
kvm_host = Host.objects.get(user=request.user.id, id=host_id)
def add_error(msg, type_err):
error_msg = Log(host_id=host_id,
type=type_err,
message=msg,
user_id=request.user.id
)
error_msg.save()
def get_storages():
try:
storages = {}
for name in conn.listStoragePools():
stg = conn.storagePoolLookupByName(name)
status = stg.isActive()
storages[name] = status
for name in conn.listDefinedStoragePools():
stg = conn.storagePoolLookupByName(name)
status = stg.isActive()
storages[name] = status
return storages
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def vm_conn():
try:
flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE]
auth = [flags, creds, None]
uri = 'qemu+tcp://' + kvm_host.ipaddr + '/system'
conn = libvirt.openAuth(uri, auth, 0)
return conn
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def get_vms():
try:
vname = {}
for id in conn.listDomainsID():
id = int(id)
dom = conn.lookupByID(id)
vname[dom.name()] = dom.info()[0]
for id in conn.listDefinedDomains():
dom = conn.lookupByName(id)
vname[dom.name()] = dom.info()[0]
return vname
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
if not kvm_host.login or not kvm_host.passwd:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = request.session['login_kvm']
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = request.session['passwd_kvm']
else:
return -1
return 0
else:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = kvm_host.login
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = kvm_host.passwd
else:
return -1
return 0
def get_conn_pool(pool):
try:
stg = conn.storagePoolLookupByName(pool)
return stg
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def pool_start():
try:
stg.create(0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def pool_stop():
try:
stg.destroy()
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def pool_delete():
try:
stg.undefine()
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def pool_refresh():
try:
stg.refresh(0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def get_stg_info(get):
try:
if get == "info":
if stg.info()[3] == 0:
percent = 0
else:
percent = (stg.info()[2] * 100) / stg.info()[1]
stg_info = stg.info()
stg_info.append(percent)
return stg_info
elif get == "status":
return stg.isActive()
elif get == "start":
return stg.autostart()
elif get == "list":
return stg.listVolumes()
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def get_type():
try:
xml = stg.XMLDesc(0)
return util.get_xml_path(xml, "/pool/@type")
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def get_target_path():
try:
xml = stg.XMLDesc(0)
return util.get_xml_path(xml, "/pool/target/path")
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def delete_volume(img):
try:
vol = stg.storageVolLookupByName(img)
vol.delete(0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def stg_set_autostart(pool):
try:
stg = conn.storagePoolLookupByName(pool)
stg.setAutostart(1)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def create_volume(img, size_max):
try:
size_max = int(size_max) * 1073741824
xml = """
<volume>
<name>%s.img</name>
<capacity>%s</capacity>
<allocation>0</allocation>
<target>
<format type='qcow2'/>
</target>
</volume>""" % (img, size_max)
stg.createXML(xml,0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def create_stg_pool(name_pool, path_pool):
try:
xml = """
<pool type='dir'>
<name>%s</name>
<target>
<path>%s</path>
</target>
</pool>""" % (name_pool, path_pool)
conn.storagePoolDefineXML(xml,0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def clone_volume(img, new_img):
try:
vol = stg.storageVolLookupByName(img)
xml = """
<volume>
<name>%s</name>
<capacity>0</capacity>
<allocation>0</allocation>
<target>
<format type='qcow2'/>
</target>
</volume>""" % (new_img)
stg.createXMLFrom(xml, vol, 0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def get_vl_info(listvol):
try:
volinfo = {}
if stg.isActive() != 0:
for name in listvol:
vol = stg.storageVolLookupByName(name)
xml = vol.XMLDesc(0)
size = vol.info()[1]
format = util.get_xml_path(xml, "/volume/target/format/@type")
volinfo[name] = size,format
return volinfo
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
conn = vm_conn()
errors = []
if conn == "error":
return HttpResponseRedirect('/overview/%s/' % (host_id))
pools = get_storages()
all_vm = get_vms()
if pool != 'new_stg_pool':
stg = get_conn_pool(pool)
status = get_stg_info('status')
if status == 1:
pool_refresh()
info = get_stg_info('info')
stype = get_type()
spath = get_target_path()
start = get_stg_info('start')
listvol = get_stg_info('list')
volinfo = get_vl_info(listvol)
hdd_size = range(1,321)
errors = []
if request.method == 'POST':
if request.POST.get('new_stg_pool',''):
name_pool = request.POST.get('name_pool','')
path_pool = request.POST.get('path_pool','')
simbol = re.search('[^a-zA-Z0-9\_]+', name_pool)
if len(name_pool) > 20:
msg = _('The name of the storage pool must not exceed 20 characters')
errors.append(msg)
if simbol:
msg = _('The name of the storage pool must not contain any characters and Russian characters')
errors.append(msg)
if not name_pool:
msg = _('Enter the name of the pool')
errors.append(msg)
if not path_pool:
msg = _('Enter the path of the pool')
errors.append(msg)
if not errors:
if create_stg_pool(name_pool, path_pool) is "error":
msg = _('Such a pool already exists')
errors.append(msg)
else:
stg = get_conn_pool(name_pool)
stg_set_autostart(name_pool)
if pool_start() is "error":
msg = _('Pool is created, but when I run the pool fails, you may specify the path does not exist')
errors.append(msg)
return HttpResponseRedirect('/storage/%s/%s/' % (host_id, name_pool))
else:
msg = _('Creating a storage pool: ')
msg = msg + name_pool
add_error(msg,'user')
return HttpResponseRedirect('/storage/%s/%s/' % (host_id, name_pool))
if errors:
return render_to_response('storage.html', locals())
if request.POST.get('stop_pool',''):
pool_stop()
msg = _('Stop storage pool: ')
msg = msg + pool
add_error(msg,'user')
return HttpResponseRedirect('/storage/%s/%s/' % (host_id, pool))
if request.POST.get('start_pool',''):
pool_start()
msg = _('Start storage pool: ')
msg = msg + pool
add_error(msg,'user')
return HttpResponseRedirect('/storage/%s/%s/' % (host_id, pool))
if request.POST.get('del_pool',''):
pool_delete()
msg = _('Delete storage pool: ')
msg = msg + pool
add_error(msg,'user')
return HttpResponseRedirect('/storage/%s/' % (host_id))
if request.POST.get('vol_del',''):
img = request.POST['img']
delete_volume(img)
msg = _('Delete image: ')
msg = msg + img
add_error(msg,'user')
return HttpResponseRedirect('/storage/%s/%s/' % (host_id, pool))
if request.POST.get('vol_add',''):
img = request.POST.get('img','')
size_max = request.POST.get('size_max','')
simbol = re.search('[^a-zA-Z0-9\_]+', img)
if len(img) > 20:
msg = _('The name of the images must not exceed 20 characters')
errors.append(msg)
if simbol:
msg = _('The name of the image must not contain any characters and Russian characters')
errors.append(msg)
if not img:
msg = _('Enter image name')
errors.append(msg)
if not size_max:
msg = _('Enter image size')
errors.append(msg)
if not errors:
create_volume(img, size_max)
msg = _('Create image: ')
msg = msg + img + '.img'
add_error(msg,'user')
return HttpResponseRedirect('/storage/%s/%s/' % (host_id, pool))
if request.POST.get('vol_clone',''):
img = request.POST.get('img','')
new_img = request.POST.get('new_img','')
simbol = re.search('[^a-zA-Z0-9\_]+', new_img)
new_img = new_img + '.img'
if new_img == '.img':
msg = _('Enter image name')
errors.append(msg)
if len(new_img) > 20:
msg = _('The name of the images must not exceed 20 characters')
errors.append(msg)
if simbol:
msg = _('The name of the image must not contain any characters and Russian characters')
errors.append(msg)
if new_img in listvol:
msg = _('The image of the same name already exists')
errors.append(msg)
if re.search('.ISO', img) or re.search('.iso', img):
msg = _('You can only clone a virtual machine images')
errors.append(msg)
if not errors:
clone_volume(img, new_img)
msg = _('Cloning image: ')
msg = msg + img + ' => ' + new_img
add_error(msg,'user')
return HttpResponseRedirect('/storage/%s/%s/' % (host_id, pool))
conn.close()
return render_to_response('storage.html', locals())
0
Example 9
Project: django-wikiapp Source File: views.py
@login_required
def edit_article(request, title,
group_slug=None, bridge=None,
article_qs=ALL_ARTICLES,
ArticleClass=Article, # to get the DoesNotExist exception
ArticleFormClass=ArticleForm,
template_name='edit.html',
template_dir='wiki',
extra_context=None,
check_membership=False,
is_member=None,
is_private=None,
*args, **kw):
if group_slug is not None:
try:
group = bridge.get_group(group_slug)
except ObjectDoesNotExist:
raise Http404
allow_read = has_read_perm(request.user, group, is_member,
is_private)
allow_write = has_write_perm(request.user, group, is_member)
else:
group = None
allow_read = allow_write = True
if not allow_write:
return HttpResponseForbidden()
try:
article = article_qs.get_by(title, group)
except ArticleClass.DoesNotExist:
article = None
if request.method == 'POST':
form = ArticleFormClass(request.POST, instance=article)
if form.is_valid():
if request.user.is_authenticated():
form.editor = request.user
if article is None:
user_message = u"Your article was created successfully."
else:
user_message = u"Your article was edited successfully."
request.user.message_set.create(message=user_message)
if ((article is None) and (group_slug is not None)):
form.group = group
new_article, changeset = form.save()
url = get_url('wiki_article', group, kw={
'title': new_article.title,
}, bridge=bridge)
return redirect_to(request, url)
elif request.method == 'GET':
user_ip = get_real_ip(request)
lock = cache.get(title, None)
if lock is None:
lock = ArticleEditLock(title, request)
lock.create_message(request)
initial = {'user_ip': user_ip}
if group_slug is not None:
# @@@ wikiapp currently handles the group filtering, but we will
# eventually want to handle that via the bridge.
initial.update({'content_type': get_ct(group).id,
'object_id': group.id})
if article is None:
initial.update({'title': title,
'action': 'create'})
form = ArticleFormClass(initial=initial)
else:
initial['action'] = 'edit'
form = ArticleFormClass(instance=article,
initial=initial)
template_params = {'form': form}
if group_slug is not None:
template_params['group'] = group
if extra_context is not None:
template_params.update(extra_context)
return render_to_response(os.path.join(template_dir, template_name),
template_params,
context_instance=RequestContext(request))
0
Example 10
Project: classic.rhizome.org Source File: views.py
def orgsub_invite_welcome(request):
'''
users can be invited to join via email through the ManageMemberForm found
on the orgsub admin page in profiles. this view handles those coming from
the link provided in that email
'''
context = RequestContext(request)
user_email = request.GET.get("email")
registration_code = request.GET.get("registration_code")
breadcrumb = (("Welcome",None),)
notice = None
try:
orgsub_prospective_member = ProspectiveUser.objects.get(email=user_email)
except:
orgsub_prospective_member = False
if orgsub_prospective_member and registration_code == orgsub_prospective_member.registration_code:
orgsub_prospective_member.accepted = 1
try:
check_for_user = User.objects.get(email = user_email)
except User.DoesNotExist:
check_for_user = None
if check_for_user:
orgsub_prospective_member.user = check_for_user
orgsub_prospective_member.save()
#if user exists, check to see if user is member
if check_for_user:
try:
check_for_membership = RhizomeMembership.objects.get(user = check_for_user)
except RhizomeMembership.DoesNotExist:
check_for_membership = False
check_for_user.registration_code = orgsub_prospective_member.registration_code
check_for_user.is_active = 1
check_for_user.save()
# if user is member, update existing membership with org_sub that sent invitation
if check_for_membership:
check_for_membership.org_sub = orgsub_prospective_member.org_sub
check_for_membership.update_membership(None, check_for_membership.org_sub.expiration_date)
check_for_membership.save()
# if user is not member, create membership, add org_sub info, and update
else:
new_member_account = RhizomeMembership(user = check_for_user)
new_member_account.org_sub = orgsub_prospective_member.org_sub
org_sub_expire_date = orgsub_prospective_member.org_sub.expiration_date
new_member_account.update_membership(None,org_sub_expire_date)
new_member_account.save()
#if user doesn't exist, create both user account and membership
else:
username = user_email.split('@')[0]
try:
User.objects.get(username=username)
username = username + str(random.randint(0,1000000))
except User.DoesNotExist:
pass
password = User.objects.make_random_password(15)
new_user_account = RhizomeUser(username = username,
email = orgsub_prospective_member.email)
new_user_account.set_password(password)
new_user_account.registration_code = orgsub_prospective_member.registration_code
new_user_account.save()
welcome_email = EmailMessage()
welcome_email.subject = "Welcome to Rhizome!"
welcome_email.body = """
Welcome to Rhizome!
Here's your username and temporary password.
%s / %s
Go here to update your information: http://rhizome.org/profiles/edit/
Thanks,
--The Rhizome Team
""" % (new_user_account.username, password)
welcome_email.to = [user_email]
welcome_email.bcc = [admin[1] for admin in settings.ADMINS]
welcome_email.send(fail_silently=False)
new_member_account = RhizomeMembership(user = new_user_account)
new_member_account.org_sub = orgsub_prospective_member.org_sub
new_member_account.update_membership(None, new_member_account.org_sub.expiration_date)
new_member_account.save()
user_account = User.objects.get(email = user_email)
membership = RhizomeMembership.objects.get(user = user_account)
else:
user_account = None
membership = None
notice = "Either this account has already registered or your \
registration verification number is invalid."
d = {
"user_account":user_account,
"membership":membership,
"breadcrumb":breadcrumb,
"notice":notice
}
return render_to_response( "accounts/welcome_orgsub.html", d, context)
0
Example 11
Project: tendenci Source File: views.py
@ssl_required
def register(request, success_url=None,
form_class=RegistrationForm, profile_callback=None,
template_name='registration/registration_form.html',
event_id=None,
extra_context=None):
"""
Allow a new user to register an account.
Following successful registration, issue a redirect; by default,
this will be whatever URL corresponds to the named URL pattern
``registration_complete``, which will be
``/accounts/register/complete/`` if using the included URLConf. To
change this, point that named pattern at another URL, or pass your
preferred URL as the keyword argument ``success_url``.
By default, ``registration.forms.RegistrationForm`` will be used
as the registration form; to change this, pass a different form
class as the ``form_class`` keyword argument. The form class you
specify must have a method ``save`` which will create and return
the new ``User``, and that method must accept the keyword argument
``profile_callback`` (see below).
To enable creation of a site-specific user profile object for the
new user, pass a function which will create the profile object as
the keyword argument ``profile_callback``. See
``RegistrationManager.create_inactive_user`` in the file
``models.py`` for details on how to write this function.
By default, use the template
``registration/registration_form.html``; to change this, pass the
name of a template as the keyword argument ``template_name``.
**Required arguments**
None.
**Optional arguments**
``form_class``
The form class to use for registration.
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context.
``profile_callback``
A function which will be used to create a site-specific
profile instance for the new ``User``.
``success_url``
The URL to redirect to on successful registration.
``template_name``
A custom template to use.
**Context:**
``form``
The registration form.
Any extra variables supplied in the ``extra_context`` argument
(see above).
**Template:**
registration/registration_form.html or ``template_name`` keyword
argument.
"""
# check if this site allows self registration, if not, redirect to login page
allow_self_registration = get_setting('module', 'users', 'selfregistration')
if not allow_self_registration:
return HttpResponseRedirect(reverse('auth_login'))
form_params = {}
if request.session.get('form_params', None):
form_params = request.session.pop('form_params')
if request.method == 'POST':
form = form_class(data=request.POST, files=request.FILES, **form_params)
if form.is_valid():
# This is for including a link in the reg email back to the event viewed
event = None
if event_id: # the user signed up via an event
from tendenci.apps.events.models import Event
event = get_object_or_404(Event, pk=event_id)
new_user = form.save(profile_callback=profile_callback, event=event)
# success_url needs to be dynamically generated here; setting a
# a default value using reverse() will cause circular-import
# problems with the default URLConf for this application, which
# imports this file.
# add to the default group(s)
default_user_groups =[g.strip() for g in (get_setting('module', 'users', 'defaultusergroup')).split(',')]
if default_user_groups:
from tendenci.apps.user_groups.models import Group, GroupMembership
from django.db.models import Q
for group_name in default_user_groups:
groups = Group.objects.filter(Q(name=group_name) | Q(label=group_name)).filter(allow_self_add=1, status=1, status_detail='active')
if groups:
group = groups[0]
else:
# group doesnot exist, so create the group
group = Group()
group.name = group_name
group.label = group_name
group.type = 'distribution'
group.show_as_option = 1
group.allow_self_add = 1
group.allow_self_remove = 1
group.creator = new_user
group.creator_username = new_user.username
group.owner = new_user
group.owner_username = new_user.username
try:
group.save()
except:
group = None
if group:
gm = GroupMembership()
gm.group = group
gm.member = new_user
gm.creator_id = new_user.id
gm.creator_username = new_user.username
gm.owner_id = new_user.id
gm.owner_username = new_user.username
gm.save()
EventLog.objects.log(instance=new_user)
return HttpResponseRedirect(success_url or reverse('registration_complete'))
elif form.similar_email_found:
messages.add_message(
request, messages.INFO,
_(u"An account already exists for the email %(email)s." % {
'email': request.POST.get('email_0') or request.POST.get('email_1')}))
querystring = 'registration=True'
return HttpResponseRedirect(reverse('auth_password_reset')+ "?%s" % querystring)
else:
allow_same_email = request.GET.get('registration_approved', False)
form_params = {'allow_same_email' : allow_same_email }
request.session['form_params'] = form_params
form = form_class(**form_params)
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{ 'form': form },
context_instance=context)
0
Example 12
Project: baruwa Source File: views.py
@login_required
def report(request, report_kind):
"displays a report"
report_kind = int(report_kind)
template = "reports/piereport.html"
active_filters = []
if report_kind == 1:
data = run_query('from_address', {'from_address__exact': ""},
'-num_count', request, active_filters)
pie_data = pack_json_data(data, 'from_address', 'num_count')
report_title = _("Top senders by quantity")
elif report_kind == 2:
data = run_query('from_address', {'from_address__exact': ""},
'-total_size', request, active_filters)
pie_data = pack_json_data(data, 'from_address', 'total_size')
report_title = _("Top senders by volume")
elif report_kind == 3:
data = run_query('from_domain', {'from_domain__exact': ""},
'-num_count', request, active_filters)
pie_data = pack_json_data(data, 'from_domain', 'num_count')
report_title = _("Top sender domains by quantity")
elif report_kind == 4:
data = run_query('from_domain', {'from_domain__exact': ""},
'-total_size', request, active_filters)
pie_data = pack_json_data(data, 'from_domain', 'total_size')
report_title = _("Top sender domains by volume")
elif report_kind == 5:
data = run_query('to_address', {'to_address__exact': ""},
'-num_count', request, active_filters)
pie_data = pack_json_data(data, 'to_address', 'num_count')
report_title = _("Top recipients by quantity")
elif report_kind == 6:
data = run_query('to_address', {'to_address__exact': ""},
'-total_size', request, active_filters)
pie_data = pack_json_data(data, 'to_address', 'total_size')
report_title = _("Top recipients by volume")
elif report_kind == 7:
data = run_query('to_domain', {'to_domain__exact': "",
'to_domain__isnull': False}, '-num_count', request,
active_filters)
pie_data = pack_json_data(data, 'to_domain', 'num_count')
report_title = _("Top recipient domains by quantity")
elif report_kind == 8:
data = run_query('to_domain', {'to_domain__exact': "",
'to_domain__isnull': False}, '-total_size',
request, active_filters)
pie_data = pack_json_data(data, 'to_domain', 'total_size')
report_title = _("Top recipient domains by volume")
elif report_kind == 9:
from baruwa.messages.models import SpamScores
filter_list = []
addrs = []
counts = []
scores = []
act = 3
if not request.user.is_superuser:
addrs = request.session['user_filter']['addresses']
act = request.session['user_filter']['account_type']
if request.session.get('filter_by', False):
filter_list = request.session.get('filter_by')
get_active_filters(filter_list, active_filters)
data = SpamScores.objects.all(request.user, filter_list, addrs, act)
for index, row in enumerate(data):
value = index + 1
scores.append({'value': value, 'text': str(row.score)})
counts.append({'y': int(row.count),
'tooltip': 'Score ' + str(row.score) + ': ' + str(row.count)})
if request.is_ajax():
data = [obj.obj_to_dict() for obj in data]
pie_data = {'scores': scores, 'count': counts}
template = "reports/barreport.html"
report_title = _("Spam Score distribution")
elif report_kind == 10:
data = run_hosts_query(request, active_filters)
pie_data = pack_json_data(data, 'clientip', 'num_count')
if request.is_ajax():
from baruwa.messages.templatetags.messages_extras import \
tds_geoip, tds_hostname
for row in data:
row['country'] = tds_geoip(row['clientip'])
row['hostname'] = tds_hostname(row['clientip'])
report_title = _("Top mail hosts by quantity")
template = "reports/relays.html"
elif report_kind == 11:
from baruwa.messages.models import MessageTotals
filter_list = []
addrs = []
dates = []
mail_total = []
spam_total = []
virus_total = []
size_total = []
act = 3
if not request.user.is_superuser:
addrs = request.session['user_filter']['addresses']
act = request.session['user_filter']['account_type']
if request.session.get('filter_by', False):
filter_list = request.session.get('filter_by')
get_active_filters(filter_list, active_filters)
data = MessageTotals.objects.all(request.user, filter_list, addrs, act)
for row in data:
dates.append(str(row.date))
mail_total.append(int(row.mail_total))
spam_total.append(int(row.spam_total))
virus_total.append(int(row.virus_total))
size_total.append(int(row.size_total))
pie_data = {'dates': [{'value': index + 1, 'text': date}
for index, date in enumerate(dates)],
'mail': [{'y': total,
'tooltip': 'Mail totals on ' + dates[index] + ': ' + str(total)}
for index, total in enumerate(mail_total)],
'spam': [{'y': total,
'tooltip': 'Spam totals on ' + dates[index] + ': ' + str(total)}
for index, total in enumerate(spam_total)],
'virii': [{'y': total,
'tooltip': 'Virus totals on ' + dates[index] + ': ' + str(total)}
for index, total in enumerate(virus_total)],
'volume': size_total,
#'volume_labels': [{'value': total,
#'text': str(filesizeformat(total))} for total in size_total],
'mail_total': sum(mail_total),
'spam_total': sum(spam_total),
'virus_total': sum(virus_total),
'volume_total': sum(size_total)}
try:
vpct = "%.1f" % ((1.0 * sum(virus_total) / sum(mail_total)) * 100)
spct = "%.1f" % ((1.0 * sum(spam_total) / sum(mail_total)) * 100)
except ZeroDivisionError:
vpct = "0.0"
spct = "0.0"
pie_data['vpct'] = vpct
pie_data['spct'] = spct
#graph_totals = {}
if request.is_ajax():
data = [obj.obj_to_dict() for obj in data]
report_title = _("Total messages [ After SMTP ]")
template = "reports/listing.html"
filter_form = FilterForm()
if request.is_ajax():
response = anyjson.dumps({'items': list(data), 'pie_data': pie_data})
return HttpResponse(response,
content_type='application/javascript; charset=utf-8')
else:
if not report_kind in [9, 11]:
pie_data = anyjson.dumps(pie_data)
return render_to_response(template, {'pie_data': pie_data,
'top_items': data, 'report_title': report_title,
'report_kind': report_kind, 'active_filters': active_filters,
'form': filter_form}, context_instance=RequestContext(request))
0
Example 13
@csrf_exempt
def serve_rpc_request(request):
'''
Handles rpc calls based on the content type of the request or
returns the method docuementation page if the request
was a GET.
**Parameters**
``request``
the Django HttpRequest object
'''
if request.method == "POST" and int(request.META.get('CONTENT_LENGTH', 0)) > 0:
# Handle POST request with RPC payload
if LOG_REQUESTS_RESPONSES:
logger.debug('Incoming request: %s' % str(get_request_body(request)))
if is_xmlrpc_request(request):
if RESTRICT_XML:
raise Http404
if not check_request_permission(request, 'xml'):
return HttpResponseForbidden()
resp = dispatcher.xmldispatch(get_request_body(request),
request=request)
response_type = 'text/xml'
else:
if RESTRICT_JSON:
raise Http404
if not check_request_permission(request, 'json'):
return HttpResponseForbidden()
resp = dispatcher.jsondispatch(get_request_body(request),
request=request)
response_type = 'application/json'
if LOG_REQUESTS_RESPONSES:
logger.debug('Outgoing %s response: %s' % (response_type, resp))
return HttpResponse(resp, response_type)
elif request.method == 'OPTIONS':
# Handle OPTIONS request for "preflighted" requests
# see https://developer.mozilla.org/en/HTTP_access_control
response = HttpResponse('', 'text/plain')
origin = request.META.get('HTTP_ORIGIN', 'unknown origin')
response['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
response['Access-Control-Max-Age'] = 0
response['Access-Control-Allow-Credentials'] = \
str(HTTP_ACCESS_CREDENTIALS).lower()
response['Access-Control-Allow-Origin'] = HTTP_ACCESS_ALLOW_ORIGIN
response['Access-Control-Allow-Headers'] = \
request.META.get('HTTP_ACCESS_CONTROL_REQUEST_HEADERS', '')
if LOG_REQUESTS_RESPONSES:
logger.debug('Outgoing HTTP access response to: %s' % (origin))
return response
else:
# Handle GET request
if RESTRICT_METHOD_SUMMARY:
# hide the docuementation by raising 404
raise Http404
# show docuementation
methods = dispatcher.list_methods()
template_data = {
'methods': methods,
'url': URL,
# rpc4django version
'version': version(),
# restricts the ability to test the rpc server from the docs
'restrict_rpctest': RESTRICT_RPCTEST,
}
from django.template import RequestContext
return render_to_response('rpc4django/rpcmethod_summary.html',
template_data,
context_instance=RequestContext(request))
0
Example 14
def details(request, id, template_name="photos/details.html"):
"""
show the photo details
"""
photo = get_object_or_404(Image, id=id)
# @@@: test
if not photo.is_public and request.user != photo.member:
raise Http404
photo_url = photo.get_display_url()
tribes = []
projects = []
# Build a list of tribes and the photos from the pool
for tribe in Tribe.objects.filter(members=request.user):
phototribe = Tribe.objects.get(pk=tribe.id)
if phototribe.photos.filter(photo=photo).count():
tribes.append({
"name": tribe.name,
"slug": tribe.slug,
"id": tribe.id,
"has_photo": True,
})
else:
tribes.append({
"name": tribe.name,
"slug": tribe.slug,
"id": tribe.id,
"has_photo": False,
})
# Build a list of projects and the photos from the pool
for project in Project.objects.filter(members__user=request.user):
photoproject = Project.objects.get(pk=project.id)
if photoproject.photos.filter(photo=photo).count():
projects.append({
"name": project.name,
"slug": project.slug,
"id": project.id,
"has_photo": True,
})
else:
projects.append({
"name": project.name,
"slug": project.slug,
"id": project.id,
"has_photo": False,
})
title = photo.title
host = "http://%s" % get_host(request)
if photo.member == request.user:
is_me = True
else:
is_me = False
# TODO: check for authorized user and catch errors
if is_me:
if request.method == "POST" and request.POST["action"] == "add_to_project":
projectid = request.POST["project"]
myproject = Project.objects.get(pk=projectid)
if not myproject.photos.filter(photo=photo).count():
myproject.photos.create(photo=photo)
request.user.message_set.create(message=_("Successfully add photo '%s' to project") % title)
else:
# TODO: this applies to pinax in general. dont use ugettext_lazy here. its usage is fragile.
request.user.message_set.create(message=_("Did not add photo '%s' to project because it already exists.") % title)
return HttpResponseRedirect(reverse('photo_details', args=(photo.id,)))
if request.method == "POST":
if request.POST["action"] == "addtotribe":
tribeid = request.POST["tribe"]
mytribe = Tribe.objects.get(pk=tribeid)
if not mytribe.photos.filter(photo=photo).count():
mytribe.photos.create(photo=photo)
request.user.message_set.create(message=_("Successfully add photo '%s' to tribe") % title)
else:
# TODO: this applies to pinax in general. dont use ugettext_lazy here. its usage is fragile.
request.user.message_set.create(message=_("Did not add photo '%s' to tribe because it already exists.") % title)
return HttpResponseRedirect(reverse('photo_details', args=(photo.id,)))
if request.POST["action"] == "removefromtribe":
tribeid = request.POST["tribe"]
mytribe = Tribe.objects.get(pk=tribeid)
if mytribe.photos.filter(photo=photo).count():
mytribe.photos.filter(photo=photo).delete()
request.user.message_set.create(message=_("Successfully removed photo '%s' from tribe") % title)
else:
# TODO: this applies to pinax in general. dont use ugettext_lazy here. its usage is fragile.
request.user.message_set.create(message=_("Did not remove photo '%s' from tribe.") % title)
return HttpResponseRedirect(reverse('photo_details', args=(photo.id,)))
if request.POST["action"] == "addtoproject":
projectid = request.POST["project"]
myproject = Project.objects.get(pk=projectid)
if not myproject.photos.filter(photo=photo).count():
myproject.photos.create(photo=photo)
request.user.message_set.create(message=_("Successfully add photo '%s' to project") % title)
else:
# TODO: this applies to pinax in general. dont use ugettext_lazy here. its usage is fragile.
request.user.message_set.create(message=_("Did not add photo '%s' to project because it already exists.") % title)
return HttpResponseRedirect(reverse('photo_details', args=(photo.id,)))
if request.POST["action"] == "removefromproject":
projectid = request.POST["project"]
myproject = Project.objects.get(pk=projectid)
if myproject.photos.filter(photo=photo).count():
myproject.photos.filter(photo=photo).delete()
request.user.message_set.create(message=_("Successfully removed photo '%s' from project") % title)
else:
# TODO: this applies to pinax in general. dont use ugettext_lazy here. its usage is fragile.
request.user.message_set.create(message=_("Did not remove photo '%s' from project.") % title)
return HttpResponseRedirect(reverse('photo_details', args=(photo.id,)))
return render_to_response(template_name, {
"host": host,
"photo": photo,
"photo_url": photo_url,
"is_me": is_me,
"projects": projects,
"tribes": tribes,
}, context_instance=RequestContext(request))
0
Example 15
Project: virtmgr Source File: views.py
def index(request, host_id):
if not request.user.is_authenticated():
return HttpResponseRedirect('/user/login/')
def add_error(msg, type_err):
error_msg = Log(host_id=host_id,
type=type_err,
message=msg,
user_id=request.user.id
)
error_msg.save()
kvm_host = Host.objects.get(user=request.user.id, id=host_id)
def vm_conn():
flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE]
auth = [flags, creds, None]
uri = 'qemu+tcp://' + kvm_host.ipaddr + '/system'
try:
conn = libvirt.openAuth(uri, auth, 0)
return conn
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
if not kvm_host.login or not kvm_host.passwd:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = request.session['login_kvm']
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = request.session['passwd_kvm']
else:
return -1
return 0
else:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = kvm_host.login
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = kvm_host.passwd
else:
return -1
return 0
def get_all_vm():
try:
vname = {}
for id in conn.listDomainsID():
id = int(id)
dom = conn.lookupByID(id)
vname[dom.name()] = dom.info()[0]
for id in conn.listDefinedDomains():
dom = conn.lookupByName(id)
vname[dom.name()] = dom.info()[0]
return vname
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_info():
try:
info = []
xml_inf = conn.getSysinfo(0)
info.append(conn.getHostname())
info.append(conn.getInfo()[0])
info.append(conn.getInfo()[2])
info.append(util.get_xml_path(xml_inf, "/sysinfo/processor/entry[6]"))
return info
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_mem_usage():
try:
allmem = conn.getInfo()[1] * 1048576
get_freemem = conn.getMemoryStats(-1,0)
if type(get_freemem) == dict:
freemem = (get_freemem.values()[0] + get_freemem.values()[2] + get_freemem.values()[3]) * 1024
percent = (freemem * 100) / allmem
percent = 100 - percent
memusage = (allmem - freemem)
else:
memusage = None
percent = None
return allmem, memusage, percent
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_cpu_usage():
try:
prev_idle = 0
prev_total = 0
cpu = conn.getCPUStats(-1,0)
if type(cpu) == dict:
for num in range(2):
idle = conn.getCPUStats(-1,0).values()[1]
total = sum(conn.getCPUStats(-1,0).values())
diff_idle = idle - prev_idle
diff_total = total - prev_total
diff_usage = (1000 * (diff_total - diff_idle) / diff_total + 5) / 10
prev_total = total
prev_idle = idle
if num == 0:
time.sleep(1)
else:
if diff_usage < 0:
diff_usage = 0
else:
diff_usage = None
return diff_usage
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_dom(vname):
try:
dom = conn.lookupByName(vname)
return dom
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
errors = []
if request.method == 'POST':
login_kvm = request.POST.get('login_kvm','')
passwd_kvm = request.POST.get('passwd_kvm','')
if login_kvm or passwd_kvm:
request.session['login_kvm'] = login_kvm
request.session['passwd_kvm'] = passwd_kvm
return HttpResponseRedirect('/overview/%s/' % (host_id))
vname = request.POST.get('vname','')
if vname:
conn = vm_conn()
dom = get_dom(vname)
if request.POST.get('suspend',''):
try:
dom.suspend()
msg = _('Suspend VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy suspended')
errors.append(msg)
if request.POST.get('resume',''):
try:
dom.resume()
msg = _('Resume VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy resume')
errors.append(msg)
if request.POST.get('start',''):
try:
dom.create()
msg = _('Start VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy start')
errors.append(msg)
if request.POST.get('shutdown',''):
try:
dom.shutdown()
msg = _('Shutdown VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy shutdown')
errors.append(msg)
if request.POST.get('destroy',''):
try:
dom.destroy()
msg = _('Force shutdown VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy shutdown')
errors.append(msg)
if not errors:
return HttpResponseRedirect('/overview/%s/' % (host_id))
conn = vm_conn()
if conn != "error":
all_vm = get_all_vm()
host_info = get_info()
mem_usage = get_mem_usage()
cpu_usage = get_cpu_usage()
lib_virt_ver = conn.getLibVersion()
conn_type = conn.getURI()
conn.close()
else:
msg = _('Error connecting: Check the KVM login and KVM password')
errors.append(msg)
return render_to_response('overview.html', locals())
0
Example 16
Project: transifex Source File: project.py
@login_required
@one_perm_required_or_403(pr_project_add_change,
(Project, 'slug__exact', 'project_slug'))
def project_access_control_edit(request, project_slug):
project = get_object_or_404(Project, slug=project_slug)
outsourced = project.outsource
if request.method == 'POST':
form = ProjectAccessControlForm(request.POST, instance=project,
user=request.user)
if form.is_valid():
access_control = form.cleaned_data['access_control']
project_type = form.cleaned_data['project_type']
project = form.save(commit=False)
project_hub = project.outsource
hub_request = None
# TODO call signal project_outsourced_changed
if 'outsourced' != project_type:
project.outsource = None
else:
check = ProjectPermission(request.user)
if not (check.maintain(project) and check.maintain(project_hub)):
# If the user is not maintainer of both projects it does
# not associate the outsource project directly.
# It does a request instead.
try:
hub_request = HubRequest.objects.get(project=project)
except ObjectDoesNotExist:
hub_request = HubRequest(project=project)
hub_request.project_hub = project_hub
hub_request.user = request.user
hub_request.save()
messages.success(request,
_("Requested to join the '%s' project hub.") % project_hub)
# ActionLog & Notification
# TODO: Use signals
nt = 'project_hub_join_requested'
context = {'hub_request': hub_request,
'sender': request.user}
# Logging action
action_logging(request.user, [project, project_hub], nt, context=context)
if settings.ENABLE_NOTICES:
# Send notification for project hub maintainers
notification.send(project_hub.maintainers.all(), nt, context)
return HttpResponseRedirect(reverse('project_detail',args=[project.slug]),)
if 'hub' == project_type:
project.is_hub = True
else:
project.is_hub = False
if ('free_for_all' == access_control and
project_type != "outsourced"):
project.anyone_submit = True
else:
project.anyone_submit = False
# Check if cla form exists before sending the signal
if 'limited_access' == access_control and \
form.cleaned_data.has_key('cla_license_text'):
# send signal to save CLA
signals.cla_create.send(
sender='project_access_control_edit_view',
project=project,
license_text=form.cleaned_data['cla_license_text'],
request=request
)
project.save()
form.save_m2m()
handle_stats_on_access_control_edit(project)
project_outsourced_changed.send(sender=project_hub)
if outsourced and not project.outsource:
# Drop resources from all-resources release of the hub project
update_all_release(outsourced)
# Logging action
nt = 'project_hub_left'
context = {'project': project, 'project_hub': outsourced,
'sender': request.user}
action_logging(request.user, [project, outsourced], nt, context=context)
return HttpResponseRedirect(reverse('project_detail',args=[project.slug]),)
else:
form = ProjectAccessControlForm(instance=project, user=request.user)
return render_to_response('projects/project_form_access_control.html', {
'project_permission': True,
'project': project,
'form': form,
}, context_instance=RequestContext(request))
0
Example 17
Project: django-adminactions Source File: graph.py
def graph_queryset(modeladmin, request, queryset): # noqa
opts = modeladmin.model._meta
perm = "{0}.{1}".format(opts.app_label.lower(), get_permission_codename('adminactions_chart', opts))
if not request.user.has_perm(perm):
messages.error(request, _('Sorry you do not have rights to execute this action'))
return
MForm = graph_form_factory(modeladmin.model)
graph_type = table = None
extra = '{}'
try:
adminaction_requested.send(sender=modeladmin.model,
action='graph_queryset',
request=request,
queryset=queryset,
modeladmin=modeladmin)
except ActionInterrupted as e:
messages.error(request, str(e))
return
if 'apply' in request.POST:
form = MForm(request.POST)
if form.is_valid():
try:
adminaction_start.send(sender=modeladmin.model,
action='graph_queryset',
request=request,
queryset=queryset,
modeladmin=modeladmin,
form=form)
except ActionInterrupted as e:
messages.error(request, str(e))
return
try:
x = form.cleaned_data['axes_x']
# y = form.cleaned_data['axes_y']
graph_type = form.cleaned_data['graph_type']
field, model, direct, m2m = get_field_by_name(modeladmin.model, x)
cc = queryset.values_list(x).annotate(Count(x)).order_by()
if isinstance(field, ForeignKey):
data_labels = []
for value, cnt in cc:
data_labels.append(str(field.rel.to.objects.get(pk=value)))
elif isinstance(field, BooleanField):
data_labels = [str(l) for l, v in cc]
elif hasattr(modeladmin.model, 'get_%s_display' % field.name):
data_labels = []
for value, cnt in cc:
data_labels.append(smart_text(dict(field.flatchoices).get(value, value), strings_only=True))
else:
data_labels = [str(l) for l, v in cc]
data = [v for l, v in cc]
if graph_type == 'BarChart':
table = [data]
extra = """{seriesDefaults:{renderer:$.jqplot.BarRenderer,
rendererOptions: {fillToZero: true,
barDirection: 'horizontal'},
shadowAngle: -135,
},
series:[%s],
axes: {yaxis: {renderer: $.jqplot.CategoryAxisRenderer,
ticks: %s},
xaxis: {pad: 1.05,
tickOptions: {formatString: '%%d'}}
}
}""" % (json.dumps(data_labels), json.dumps(data_labels))
elif graph_type == 'PieChart':
table = [list(zip(data_labels, data))]
extra = """{seriesDefaults: {renderer: jQuery.jqplot.PieRenderer,
rendererOptions: {fill: true,
showDataLabels: true,
sliceMargin: 4,
lineWidth: 5}},
legend: {show: true, location: 'e'}}"""
except Exception as e:
messages.error(request, 'Unable to produce valid data: %s' % str(e))
else:
adminaction_end.send(sender=modeladmin.model,
action='graph_queryset',
request=request,
queryset=queryset,
modeladmin=modeladmin,
form=form)
elif request.method == 'POST':
# total = queryset.all().count()
initial = {helpers.ACTION_CHECKBOX_NAME: request.POST.getlist(helpers.ACTION_CHECKBOX_NAME),
'select_across': request.POST.get('select_across', 0)}
form = MForm(initial=initial)
else:
initial = {helpers.ACTION_CHECKBOX_NAME: request.POST.getlist(helpers.ACTION_CHECKBOX_NAME),
'select_across': request.POST.get('select_across', 0)}
form = MForm(initial=initial)
adminForm = helpers.AdminForm(form, modeladmin.get_fieldsets(request), {}, [], model_admin=modeladmin)
media = modeladmin.media + adminForm.media
ctx = {'adminform': adminForm,
'action': 'graph_queryset',
'opts': modeladmin.model._meta,
'action_short_description': graph_queryset.short_description,
'title': u"%s (%s)" % (
graph_queryset.short_description.capitalize(),
smart_text(modeladmin.opts.verbose_name_plural),
),
'app_label': queryset.model._meta.app_label,
'media': media,
'extra': extra,
'as_json': json.dumps(table),
'graph_type': graph_type}
if django.VERSION[:2] > (1, 7):
ctx.update(modeladmin.admin_site.each_context(request))
else:
ctx.update(modeladmin.admin_site.each_context())
return render_to_response('adminactions/charts.html', RequestContext(request, ctx))
0
Example 18
Project: django-goflow Source File: views.py
@login_required
def edit_model(request, id, form_class, cmp_attr=None,template=None, template_def='goflow/edit_model.html', title="",
redirect='home', submit_name='action', ok_values=('OK',), save_value=None, cancel_value='Cancel',
extra_context={}):
'''
generic handler for editing a model.
parameters:
id
workitem id (required)
form_class
model form based on goflow.apptools.forms.BaseForm (required)
cmp_attr
edit obj.cmp_attr attribute instead of obj - default=None
template
default: 'goflow/edit_%s.html' % model_lowercase
template_def
used if template not found - default: 'goflow/edit_model.html'
title
default=""
redirect
default='home'
submit_name
name for submit buttons - default='action'
ok_values
submit buttons values - default=('OK',)
save_value
save button value - default='Save'
cancel_value
cancel button value - default='Cancel'
extra_context
default={}
'''
if not template: template = 'goflow/edit_%s.html' % form_class._meta.model._meta.object_name.lower()
model_class = form_class._meta.model
workitem = WorkItem.objects.get_safe(int(id), user=request.user)
instance = workitem.instance
activity = workitem.activity
obj = instance.wfobject()
obj_context = obj
# objet composite intermédiaire
if cmp_attr:
obj = getattr(obj, cmp_attr)
template = override_app_params(activity, 'template', template)
redirect = override_app_params(activity, 'redirect', redirect)
submit_name = override_app_params(activity, 'submit_name', submit_name)
ok_values = override_app_params(activity, 'ok_values', ok_values)
cancel_value = override_app_params(activity, 'cancel_value', cancel_value)
if request.method == 'POST':
form = form_class(request.POST, instance=obj)
submit_value = request.POST[submit_name]
if submit_value == cancel_value:
return HttpResponseRedirect(redirect)
if form.is_valid():
if (submit_value == save_value):
# just save
#ob = form.save()
try:
ob = form.save(workitem=workitem, submit_value=submit_value)
except Exception, v:
raise Exception(str(v))
return HttpResponseRedirect(redirect)
if submit_value in ok_values:
# save and complete activity
#ob = form.save()
try:
ob = form.save(workitem=workitem, submit_value=submit_value)
except Exception, v:
raise Exception(str(v))
instance.condition = submit_value
instance.save()
workitem.complete(request.user)
return HttpResponseRedirect(redirect)
else:
form = form_class(instance=obj)
# precheck
form.pre_check(obj_context, user=request.user)
context = { 'form': form, 'object':obj, 'object_context':obj_context,
'instance':instance, 'workitem':workitem,
'submit_name':submit_name, 'ok_values':ok_values,
'save_value':save_value, 'cancel_value':cancel_value,
'title':title}
context.update(extra_context)
return render_to_response((template, template_def), context,
context_instance=RequestContext(request))
0
Example 19
@login_required
def modify(request, project_url_path, tab_id = 1):
# redirect if the url path is not in the correct format
resp = force_url_paths(modify, project_url_path)
if resp: return resp
project = get_object_or_404(Project, url_path = project_url_path)
screenshots = Screenshot.objects.filter(project = project)
# if someone tries to edit a project they shouldn't be able to
if not (request.user in project.authors.all() or request.user.info.mentor):
return HttpResponseRedirect(reverse(show, args = (project.url_path,)))
# default forms
project_form = ProjectForm(instance = project)
cloned_repo_form = ClonedRepositoryForm(instance = project.repository)
feed_repo_form = FeedRepositoryForm(instance = project.repository)
blog_form = BlogForm(instance = project.blog)
screenshot_form = UploadScreenshotForm()
# if changes should be saved or rejected
if request.POST:
# uploading a screenshot
if 'screenshot_upload' in request.POST:
form = UploadScreenshotForm(request.POST, request.FILES)
if form.is_valid():
Screenshot.create(form, request.FILES["file"], project)
else:
screenshot_form = form
# wrote a post with the js overlay
if 'title' in request.POST and 'markdown' in request.POST:
from dashboard.views.blogs import create_post_real
return create_post_real(request.POST)
# editing the project's information
elif 'title' in request.POST:
form = ProjectForm(request.POST)
# if the form is valid, save
if form.is_valid():
project.title = form.cleaned_data['title']
project.website = form.cleaned_data['website']
project.wiki = form.cleaned_data['wiki']
project.description = form.cleaned_data['description']
project.active = form.cleaned_data['active']
project.save()
project_form = ProjectForm(instance = project)
# otherwise, display the errors
else:
project_form = form
# editing a cloned repository
elif 'clone_url' in request.POST:
form = ClonedRepositoryForm(request.POST)
if form.is_valid():
project.repository.web_url = form.cleaned_data['web_url']
project.repository.clone_url = form.cleaned_data['clone_url']
project.repository.vcs = form.cleaned_data['vcs']
project.repository.from_feed = False
project.repository.save()
cloned_repo_form = ClonedRepositoryForm(instance = project.repository)
else:
cloned_repo_form = form
# editing a feed repository
elif 'repo_rss' in request.POST:
form = FeedRepositoryForm(request.POST)
if form.is_valid():
project.repository.repo_rss = form.cleaned_data['repo_rss']
project.repository.cmd = form.cleaned_data['cmd']
project.repository.web_url = form.cleaned_data['web_url']
project.repository.from_feed = True
project.repository.save()
feed_repo_form = FeedRepositoryForm(instance = project.repository)
else:
feed_repo_form = form
# editing a feed-based blog
elif 'url' in request.POST:
form = BlogForm(request.POST)
if form.is_valid():
project.blog.url = form.cleaned_data['url']
project.blog.rss = form.cleaned_data['rss']
project.blog.from_feed = True
project.blog.save()
blog_form = BlogForm(instance = project.blog)
else:
blog_form = form
# switching to hosted blog
elif 'switch-to-hosted' in request.POST:
project.blog.from_feed = False
project.blog.save()
return render_to_response('projects/modify.html', {
'project': project,
'screenshots': screenshots,
'project_form': project_form,
'cloned_repo_form': cloned_repo_form,
'feed_repo_form': feed_repo_form,
'blog_form': blog_form,
'screenshot_form': screenshot_form,
'post_form': BlogPostForm(),
'repo': project.repository,
'tab': int(tab_id)
}, context_instance = RequestContext(request))
0
Example 20
def instance_create(request):
"""Creates an instance with the policy given by realm_id.
Uses image_id and realm_id from the application/x-www-form-urlencoded
format. Both of these fields are required.
"""
# Get multipart-form data: image_id, realm_id, hwp_name, name
try:
image_id = request.POST["image_id"]
realm_id = request.POST["realm_id"]
except KeyError:
return HttpResponseBadRequest("Both an image_id and a realm_id must " \
"be specified.")
# Get the libcloud driver
try:
policy = Policy.objects.get(id=realm_id)
except ObjectDoesNotExist:
return HttpResponseBadRequest("The requested realm_id was not found.")
provider = policy.get_next_provider(image_id)
driver = provider.get_client()
# Get the RealImage object
try:
aggregate_image = AggregateImage.objects.get(id=image_id)
except ObjectDoesNotExist:
return HttpResponseBadRequest("The requested image_id was not found.")
try:
real_image = RealImage.objects.get(
aggregate_image=aggregate_image,
provider=provider,
)
except ObjectDoesNotExist:
return HttpResponseBadRequest("There is no aggregate image image " \
"matching this provider.")
# Get the libcloud node object
image = None
for node in driver.list_images():
if node.id == real_image.image_id:
image = node
break
if not image:
#TODO: This should probably return an HTTP error code instead of
# raising an exception
raise ValueError("Image was not found in the provider: %s" % \
real_image
)
# Get an instance size
size = driver.list_sizes()[0]
# Add instance to database
# We do this before the actual creating of the image so we can get the
# instance_id
database_instance = Instance(
image = aggregate_image,
owner_id = "",
name = "",
provider = provider,
instance_id = -1,
policy = policy,
)
database_instance.save()
# Start the instance!
instance = driver.create_node(
image=image,
name="dcmux-%s" % database_instance.id,
size=size,
)
# Update instance_id in database
database_instance.instance_id = instance.id
database_instance.save()
return render_to_response(
'dcmux/instances.xml',
{
"images_uri": uri_lookup(request, "images"),
"instances_uri": uri_lookup(request, "instances"),
"instances": [instance],
},
mimetype="application/xml",
)
0
Example 21
def edit(request, slug, rev_id=None, template_name='wakawaka/edit.html',
extra_context=None, wiki_page_form=WikiPageForm,
wiki_delete_form=DeleteWikiPageForm):
"""
Displays the form for editing and deleting a page.
"""
if extra_context is None:
extra_context = {}
# Get the page for slug and get a specific revision, if given
try:
queryset = WikiPage.objects.all()
page = queryset.get(slug=slug)
rev = page.current
initial = {'content': page.current.content}
# Do not allow editing wiki pages if the user has no permission
if not request.user.has_perms(('wakawaka.change_wikipage', 'wakawaka.change_revision' )):
return HttpResponseForbidden(ugettext('You don\'t have permission to edit pages.'))
if rev_id:
# There is a specific revision, fetch this
rev_specific = Revision.objects.get(pk=rev_id)
if rev.pk != rev_specific.pk:
rev = rev_specific
rev.is_not_current = True
initial = {'content': rev.content, 'message': _('Reverted to "%s"' % rev.message)}
# This page does not exist, create a dummy page
# Note that it's not saved here
except WikiPage.DoesNotExist:
# Do not allow adding wiki pages if the user has no permission
if not request.user.has_perms(('wakawaka.add_wikipage', 'wakawaka.add_revision',)):
return HttpResponseForbidden(ugettext('You don\'t have permission to add wiki pages.'))
page = WikiPage(slug=slug)
page.is_initial = True
rev = None
initial = {'content': _('Describe your new page %s here...' % slug),
'message': _('Initial revision')}
# Don't display the delete form if the user has nor permission
delete_form = None
# The user has permission, then do
if request.user.has_perm('wakawaka.delete_wikipage') or \
request.user.has_perm('wakawaka.delete_revision'):
delete_form = wiki_delete_form(request)
if request.method == 'POST' and request.POST.get('delete'):
delete_form = wiki_delete_form(request, request.POST)
if delete_form.is_valid():
return delete_form.delete_wiki(request, page, rev)
# Page add/edit form
form = wiki_page_form(initial=initial)
if request.method == 'POST':
form = wiki_page_form(data=request.POST)
if form.is_valid():
# Check if the content is changed, except there is a rev_id and the
# user possibly only reverted the HEAD to it
if not rev_id and initial['content'] == form.cleaned_data['content']:
form.errors['content'] = (_('You have made no changes!'),)
# Save the form and redirect to the page view
else:
try:
# Check that the page already exist
queryset = WikiPage.objects.all()
page = queryset.get(slug=slug)
except WikiPage.DoesNotExist:
# Must be a new one, create that page
page = WikiPage(slug=slug)
page.save()
form.save(request, page)
kwargs = {
'slug': page.slug,
}
redirect_to = reverse('wakawaka_page', kwargs=kwargs)
messages.success(request, ugettext('Your changes to %s were saved' % page.slug))
return HttpResponseRedirect(redirect_to)
template_context = {
'form': form,
'delete_form': delete_form,
'page': page,
'rev': rev,
}
template_context.update(extra_context)
return render_to_response(template_name, template_context,
RequestContext(request))
0
Example 22
Project: coursys Source File: views.py
@requires_discipline_user
def edit_case_info(request, course_slug, case_slug, field):
"""
View function for all of the "edit this aspect of the case" steps. Uses the STEP_* dictionaries to get relevant strings/classes.
"""
course = get_object_or_404(CourseOffering, slug=course_slug)
case = get_object_or_404(DisciplineCaseBase, slug=case_slug, offering__slug=course_slug)
case = case.subclass()
# permisson checks
roles = request.session['discipline-'+course_slug]
if not case.can_edit(field):
# once instructor finished, don't allow editing those fields
return ForbiddenResponse(request, "letter has been sent: cannot edit this field")
elif isinstance(case, DisciplineCaseInstr) and "INSTR" not in roles:
# only instructor can edit those fields
return ForbiddenResponse(request, "only the instructor can edit this field")
elif isinstance(case, DisciplineCaseChair) and "DEPT" not in roles:
# only discipline admins can edit chair fields
return ForbiddenResponse(request, "only the Chair (or delegate) can edit this field")
FormClass = STEP_FORM[field]
if request.method == 'POST':
form = FormClass(request.POST, instance=case)
if form.is_valid():
c = form.save()
if field in PRE_LETTER_STEPS:
# letter hasn't been reviewed if anything changes
c.letter_review = False
c.letter_sent = 'WAIT'
c.penalty_implemented = False
c.save()
#LOG EVENT#
l = LogEntry(userid=request.user.username,
description=("edit discipline case %s in %s: changed %s") % (c.slug, c.offering, STEP_DESC[field]),
related_object=c)
l.save()
messages.add_message(request, messages.SUCCESS, "Updated " + STEP_DESC[field] + '.')
# set identical value for group members as requested
also_contact = []
for postfield in request.POST:
match = also_set_re.match(postfield)
if not match or request.POST[postfield] != "on":
continue
field = match.group('field')
caseid = match.group('caseid')
cases = DisciplineCaseBase.objects.filter(id=caseid)
if len(cases) != 1 or cases[0].group != case.group:
continue
c0 = cases[0].subclass()
if not c0.can_edit(field):
messages.add_message(request, messages.ERROR,
"Case for %s is finished: cannot update %s." % (c0.student.name(), STEP_DESC[field]))
continue
if field=="contacted" and form.cleaned_data[field]=='MAIL':
# special case handled below
also_contact.append(c0)
else:
setattr(c0, field, form.cleaned_data[field])
if field in PRE_LETTER_STEPS:
c0.letter_review = False
c0.save()
messages.add_message(request, messages.SUCCESS,
"Also updated %s for %s." % (STEP_DESC[field], c0.student.name()))
if hasattr(c, 'send_letter_now'):
# send instructor's letter
assert case.public_attachments_size() <= MAX_ATTACHMENTS # should be ensured by "review letter" step
c.send_letter(_currentuser(request))
messages.add_message(request, messages.INFO, "Letter sent to student summarizing case.")
if hasattr(c, 'send_contact_mail'):
# send initial contact email
c.send_contact_email()
messages.add_message(request, messages.INFO, "Email sent to student notifying of case.")
for c0 in also_contact:
textkey = 'also-contact_email_text-' + str(c0.id)
if textkey in request.POST and request.POST[textkey]=="on":
# only send the email if text was updated too
c0.contacted = form.cleaned_data['contacted']
c0.contact_email_text = form.cleaned_data['contact_email_text']
c0.save()
messages.add_message(request, messages.SUCCESS,
"Also updated %s for %s." % (STEP_DESC['contacted'], c0.student.name()))
c0.send_contact_email()
messages.add_message(request, messages.INFO, "Also emailed %s." % (c0.student.name()))
else:
# if not, give an error message.
messages.add_message(request, messages.ERROR,
mark_safe('Email not sent to %s since their "Contact Email Text" was not updated. You can <a href="%s">edit their contact info</a> if you wish.'
% (c0.student.name(),
reverse('discipline.views.edit_case_info',
kwargs={'field': 'contacted', 'course_slug': course_slug, 'case_slug': c0.slug}))))
if isinstance(case, DisciplineCaseChair):
return HttpResponseRedirect(reverse('discipline.views.show_chair', kwargs={'course_slug': course_slug, 'case_slug': case.slug}))
else:
return HttpResponseRedirect(reverse('discipline.views.show', kwargs={'course_slug': course_slug, 'case_slug': case.slug}))
else:
form = FormClass(instance=case)
templates = DisciplineTemplate.objects.filter(field__in=form.fields.keys())
tempaltesJSON = json.dumps([t.JSON_data() for t in templates])
groupmembersJSON = case.groupmembersJSON()
hasRelAct = len(case.related_activities())>0
context = {'course': course, 'case': case, 'form': form,
'templatesJSON': mark_safe(tempaltesJSON), 'groupmembersJSON': mark_safe(groupmembersJSON), 'hasRelAct': hasRelAct}
if field == 'letter_review':
context['currentuser'] = _currentuser(request)
return render_to_response("discipline/edit_"+field+".html", context, context_instance=RequestContext(request))
0
Example 23
Project: Observatory Source File: views.py
@login_required
def view_list(request,list_id=0,list_slug=None,view_completed=0):
"""
Display and manage items in a task list
"""
# Make sure the accessing user has permission to view this list.
# Always authorize the "mine" view. Admins can view/edit all lists.
if list_slug == "mine" or list_slug == "recent-add" or list_slug == "recent-complete" :
auth_ok =1
else:
list = get_object_or_404(List, slug=list_slug)
listid = list.id
# Check whether current user is a member of the group this list belongs to.
if list.group in request.user.groups.all() or request.user.mentor or list_slug == "mine" :
auth_ok = 1 # User is authorized for this view
else: # User does not belong to the group this list is attached to
messages.error(request, "You do not have permission to view/edit this list.")
# First check for items in the mark_done POST array. If present, change
# their status to complete.
if request.POST.getlist('mark_done'):
done_items = request.POST.getlist('mark_done')
# Iterate through array of done items and update its representation in the model
for thisitem in done_items:
p = Item.objects.get(id=thisitem)
p.completed = 1
p.completed_date = datetime.datetime.now()
p.save()
messages.success(request, "Item \"%s\" marked complete." % p.title)
# Undo: Set completed items back to incomplete
if request.POST.getlist('undo_completed_task'):
undone_items = request.POST.getlist('undo_completed_task')
for thisitem in undone_items:
p = Item.objects.get(id=thisitem)
p.completed = 0
p.save()
messages.success(request, "Previously completed task \"%s\" marked incomplete." % p.title)
# And delete any requested items
if request.POST.getlist('del_task'):
deleted_items = request.POST.getlist('del_task')
for thisitem in deleted_items:
p = Item.objects.get(id=thisitem)
p.delete()
messages.success(request, "Item \"%s\" deleted." % p.title)
# And delete any *already completed* items
if request.POST.getlist('del_completed_task'):
deleted_items = request.POST.getlist('del_completed_task')
for thisitem in deleted_items:
p = Item.objects.get(id=thisitem)
p.delete()
messages.success(request, "Deleted previously completed item \"%s\"." % p.title)
thedate = datetime.datetime.now()
created_date = "%s-%s-%s" % (thedate.year, thedate.month, thedate.day)
# Get list of items with this list ID, or filter on items assigned to me, or recently added/completed
if list_slug == "mine":
task_list = Item.objects.filter(assigned_to=request.user, completed=0)
completed_list = Item.objects.filter(assigned_to=request.user, completed=1)
elif list_slug == "recent-add":
# We'll assume this only includes uncompleted items to avoid confusion.
# Only show items in lists that are in groups that the current user is also in.
task_list = Item.objects.filter(list__group__in=(request.user.groups.all()),completed=0).order_by('-created_date')[:50]
# completed_list = Item.objects.filter(assigned_to=request.user, completed=1)
elif list_slug == "recent-complete":
# Only show items in lists that are in groups that the current user is also in.
task_list = Item.objects.filter(list__group__in=request.user.groups.all(),completed=1).order_by('-completed_date')[:50]
# completed_list = Item.objects.filter(assigned_to=request.user, completed=1)
else:
task_list = Item.objects.filter(list=list.id, completed=0)
completed_list = Item.objects.filter(list=list.id, completed=1)
if request.POST.getlist('add_task') :
form = AddItemForm(list, request.POST,initial={
'assigned_to':request.user.id,
'priority':999,
})
if form.is_valid():
# Save task first so we have a db object to play with
new_task = form.save()
# Send email alert only if the Notify checkbox is checked AND the assignee is not the same as the submittor
# Email subect and body format are handled by templates
if "notify" in request.POST :
if new_task.assigned_to != request.user :
# Send email
email_subject = render_to_string("todo/email/assigned_subject.txt", { 'task': new_task })
email_body = render_to_string("todo/email/assigned_body.txt", { 'task': new_task, 'site': current_site, })
try:
send_mail(email_subject, email_body, new_task.created_by.email, [new_task.assigned_to.email], fail_silently=False)
except:
messages.error(request, "Task saved but mail not sent. Contact your administrator.")
messages.success(request, "New task \"%s\" has been added." % new_task.title)
return HttpResponseRedirect(request.path)
else:
if list_slug != "mine" and list_slug != "recent-add" and list_slug != "recent-complete" : # We don't allow adding a task on the "mine" view
form = AddItemForm(list, initial={
'assigned_to':request.user.id,
'priority':999,
} )
if request.user.mentor :
can_del = 1
return render_to_response('todo/view_list.html', locals(), context_instance=RequestContext(request))
0
Example 24
Project: django-templatesadmin Source File: views.py
@never_cache
@user_passes_test(lambda u: user_in_templatesadmin_group(u))
@login_required
def modify(request,
path,
template_name='templatesadmin/edit.html',
base_form=TemplateForm,
available_template_dirs=TEMPLATESADMIN_TEMPLATE_DIRS):
template_path = _fixpath(path)
# Check if file is within template-dirs
if not any([template_path.startswith(templatedir) for templatedir in available_template_dirs]):
request.user.message_set.create(message=_('Sorry, that file is not available for editing.'))
return HttpResponseRedirect(reverse('templatesadmin-overview'))
if request.method == 'POST':
formclass = base_form
for hook in TEMPLATESADMIN_EDITHOOKS:
formclass.base_fields.update(hook.contribute_to_form(template_path))
form = formclass(request.POST)
if form.is_valid():
content = form.cleaned_data['content']
try:
for hook in TEMPLATESADMIN_EDITHOOKS:
pre_save_notice = hook.pre_save(request, form, template_path)
if pre_save_notice:
request.user.message_set.create(message=pre_save_notice)
except TemplatesAdminException, e:
request.user.message_set.create(message=e.message)
return HttpResponseRedirect(request.build_absolute_uri())
# Save the template
try:
f = open(template_path, 'r')
file_content = f.read()
f.close()
# browser tend to strip newlines from <textarea/>s before
# HTTP-POSTing: re-insert them if neccessary
# content is in dos-style lineending, will be converted in next step
if (file_content[-1] == '\n' or file_content[:-2] == '\r\n') \
and content[:-2] != '\r\n':
content = u"%s\r\n" % content
# Template is saved in unix-style, save in unix style.
if None == search("\r\n", file_content):
content = content.replace("\r\n", "\n")
f = codecs.open(template_path, 'w', 'utf-8')
f.write(content)
f.close()
except IOError, e:
request.user.message_set.create(
message=_('Template "%(path)s" has not been saved! Reason: %(errormsg)s' % {
'path': path,
'errormsg': e
})
)
return HttpResponseRedirect(request.build_absolute_uri())
try:
for hook in TEMPLATESADMIN_EDITHOOKS:
post_save_notice = hook.post_save(request, form, template_path)
if post_save_notice:
request.user.message_set.create(message=post_save_notice)
except TemplatesAdminException, e:
request.user.message_set.create(message=e.message)
return HttpResponseRedirect(request.build_absolute_uri())
request.user.message_set.create(
message=_('Template "%s" was saved successfully.' % path)
)
return HttpResponseRedirect(reverse('templatesadmin-overview'))
else:
template_file = codecs.open(template_path, 'r', 'utf-8').read()
formclass = TemplateForm
for hook in TEMPLATESADMIN_EDITHOOKS:
formclass.base_fields.update(hook.contribute_to_form(template_path))
form = formclass(
initial={'content': template_file}
)
template_context = {
'messages': request.user.get_and_delete_messages(),
'form': form,
'short_path': path,
'template_path': path,
'template_writeable': os.access(template_path, os.W_OK),
'ADMIN_MEDIA_PREFIX': settings.ADMIN_MEDIA_PREFIX,
}
return render_to_response(template_name, template_context,
RequestContext(request))
0
Example 25
Project: classic.rhizome.org Source File: views.py
@login_required
def edit_profile(request):
context = RequestContext(request)
rhizomeuser = request.user.get_profile()
initial_list_data = [l.listid for l in Member.objects.filter(user=rhizomeuser, deleted = 0)]
personal_info_form = EditPersonalInfoForm(instance=rhizomeuser)
account_info_form = EditAccountInfoForm(instance=rhizomeuser)
bio_form = EditBioForm(instance=rhizomeuser)
add_info_form = EditAdditionalInfoForm(instance=rhizomeuser)
try:
address = rhizomeuser.address('billing')
address_form = UserBillingAddressForm(instance=address)
except:
address_form = UserBillingAddressForm()
set_password_form = SetPasswordForm(rhizomeuser)
manage_email_form = ManageForm(request.POST or None, initial={'mailinglists':initial_list_data})
ip_address = request.META.get('REMOTE_ADDR', 'unknown')
updated = ''
if request.method == 'POST':
response = ''
if request.POST['form'] == "personal_info":
personal_info_form = EditPersonalInfoForm(request.POST or None,
instance=rhizomeuser and RhizomeUser.objects.get(id=rhizomeuser.id))
if personal_info_form.is_valid():
rhizomeuser = personal_info_form.save()
rhizomeuser.save()
updated = "pass"
else:
updated = "fail"
if request.POST['form'] == "address_form":
try:
address_form = UserBillingAddressForm(request.POST or None, instance=address)
except:
address_form = UserBillingAddressForm(request.POST or None)
if address_form.is_valid():
address_form.save(rhizomeuser)
updated = "pass"
else:
updated = "fail"
if request.POST['form'] == "bio":
bio_form = EditBioForm(request.POST or None,
instance=rhizomeuser and RhizomeUser.objects.get(id=rhizomeuser.id))
if bio_form.is_valid():
rhizomeuser = bio_form.save()
rhizomeuser.save()
updated = "pass"
else:
updated = "fail"
if request.POST['form'] == "account_info":
account_info_form = EditAccountInfoForm(request.POST or None, request.FILES or None,
instance=rhizomeuser and RhizomeUser.objects.get(id=rhizomeuser.id))
if account_info_form.is_valid():
rhizomeuser = account_info_form.save()
rhizomeuser.save()
updated = "pass"
else:
updated = "fail"
if request.POST['form'] == "set_password":
set_password_form = SetPasswordForm(rhizomeuser,request.POST)
if set_password_form.is_valid():
rhizomeuser = set_password_form.save()
rhizomeuser.save()
updated = "pass"
else:
updated = "fail"
if request.POST['form'] == "add_info":
add_info_form = EditAdditionalInfoForm(request.POST or None,
instance=rhizomeuser and RhizomeUser.objects.get(id=rhizomeuser.id))
if add_info_form.is_valid():
rhizomeuser = add_info_form.save()
rhizomeuser.save()
updated = "pass"
else:
updated = "fail"
if request.POST['form'] == "manage_email_form":
manage_email_form = ManageForm(request.POST)
if manage_email_form.is_valid():
mailinglists = manage_email_form.cleaned_data['mailinglists']
notice = manage_email_form.save(request, mailinglists)
updated = "pass"
else:
updated = "fail"
if updated == 'pass':
moderator.process(rhizomeuser, request)
return HttpResponseRedirect('/profiles/edit?updated=True')
breadcrumb = (("Profiles", rhizomeuser.get_absolute_url()), ("Edit",None))
if rhizomeuser.id == request.user.id:
return render_to_response(
"accounts/edit.html",
{
"rhizomeuser":rhizomeuser,
"personal_info_form":personal_info_form,
"account_info_form":account_info_form,
"bio_form":bio_form,
"add_info_form":add_info_form,
"set_password_form":set_password_form,
"manage_email_form":manage_email_form,
"address_form":address_form,
"updated": updated,
"breadcrumb":breadcrumb,
"today": datetime.datetime.now(),
},
context
)
else:
return HttpResponseRedirect(reverse(profiles_list))
0
Example 26
Project: Subterfuge Source File: views.py
def conf(request, module):
# Read in subterfuge.conf
with open(str(os.path.dirname(__file__)).rstrip("abcdefghijklmnnnopqrstruvwxyz") + 'subterfuge.conf', 'r') as file:
conf = file.readlines()
# Subterfuge Settings Configuration
# Edit subterfuge.conf
if module == "settings":
#Attack Setup
try:
setup.objects.update(iface = request.POST["iface"])
conf[15] = request.POST["iface"] + "\n"
print "Using Interface => " + request.POST["iface"]
except:
pass
try:
if request.POST["auto"] == "true":
setup.objects.update(autoconf = "yes")
conf[20] = "yes" + "\n"
print "Auto Configure => yes"
else:
setup.objects.update(autoconf = "no")
conf[20] = "no" + "\n"
print "Auto Configure => no"
except:
pass
try:
setup.objects.update(gateway = request.POST["agw"])
conf[17] = request.POST["agw"] + "\n"
print "Using Gateway => " + request.POST["agw"]
except:
pass
try:
setup.objects.update(proxymode = request.POST["proxymode"])
print "Using Gateway => " + request.POST["proxymode"]
except:
pass
try:
setup.objects.update(gateway = request.POST["mgw"])
conf[17] = request.POST["mgw"] + "\n"
print "Using Gateway => " + request.POST["mgw"]
except:
pass
#Get the Local IP Address
try:
f = os.popen("ifconfig " + request.POST["iface"] + " | grep \"inet addr\" | sed -e \'s/.*addr://;s/ .*//\'")
temp2 = ''
temp3 = ''
temp = f.readline().rstrip('\n')
ipaddress = re.findall(r'\d*.\d*.\d*.\d*', temp)[0]
conf[26] = ipaddress + "\n"
setup.objects.update(ip = ipaddress)
except:
pass
#Configuration
try:
setup.objects.update(ploadrate = request.POST["ploadrate"])
setup.objects.update(injectrate = request.POST["injectrate"])
if request.POST["smartarp"] == "true":
setup.objects.update(smartarp = "yes")
elif request.POST["smartarp"] == "false":
setup.objects.update(smartarp = "no")
setup.objects.update(arprate = request.POST["arprate"])
except:
pass
#Vectors
try:
if request.POST["active"] == "true":
vectors.objects.filter(name = request.POST["vector"]).update(active = "yes")
else:
vectors.objects.filter(name = request.POST["vector"]).update(active = "no")
#Wireless AP Generator Settings
if request.POST["vector"] == "ARP Cache Poisoning":
arppoison.objects.update(target = request.POST["target"])
arppoison.objects.update(method = request.POST["arpmethod"])
#Wireless AP Generator Settings
if request.POST["vector"] == "Wireless AP Generator":
apgen.objects.update(essid = request.POST["essid"])
apgen.objects.update(channel = request.POST["channel"])
apgen.objects.update(atknic = request.POST["atknic"])
apgen.objects.update(netnic = request.POST["netnic"])
except:
pass
#Advanced
try:
scanip = request.POST["scantargetip"]
print "Importing Nmap scan for: " + scanip
#Get/Write Files
if request.FILES['scanresults']:
scanresults = request.FILES['scanresults']
dest = open(str(os.path.dirname(__file__)).rstrip("abcdefghijklmnnnopqrstruvwxyz") + 'utilities/scans/' + scanip + '.xml', 'wb+')
for chunk in scanresults.chunks():
dest.write(chunk)
dest.close()
#Execute Scan
os.system('python ' + str(os.path.dirname(__file__)).rstrip("abcdefghijklmnnnopqrstruvwxyz") + 'utilities/scan.py ' + scanip)
#Relay Template Variables
return render_to_response("settings.ext", {
"config" : config,
"conf" : str(config[20]).rstrip('\n'),
"iface" : result,
"gateway" : gw,
"status" : status,
"setup" : currentsetup,
})
except:
pass
if module == "update":
os.system('apt-get install subterfuge')
if module == "exportcreds":
os.system('python ' + str(os.path.dirname(__file__)).rstrip("abcdefghijklmnnnopqrstruvwxyz") + 'exportcreds.py')
#################################
#Subterfuge Module Configurations
#################################
if module == "httpinjection":
httpcodeinjection(request, conf)
elif module == "tunnelblock":
tunnelblock()
else:
for mod in installed.objects.all():
if module == mod.name:
os.system('python ' + str(os.path.dirname(__file__)).rstrip("abcdefghijklmnnnopqrstruvwxyz") + 'modules/' + module + '/' + module + '.py &')
#################################
# END MODULE CONFIGURATION
#################################
# Write to subterfuge.conf
with open(str(os.path.dirname(__file__)).rstrip("abcdefghijklmnnnopqrstruvwxyz") + 'subterfuge.conf', 'w') as file:
file.writelines(conf)
# Call Index Page
# Check Arpspoof status
command = "ps -A 1 | sed -e '/arpmitm/!d;/sed -e/d;s/^ //;s/ pts.*//'"
a = os.popen(command)
reply = a.read()
if(len(reply)>1):
status = "on"
else:
status = "off"
if module == "httpinjection" or module == "tunnelblock":
#Relay Template Variables
modules = installed.objects.all()
return render_to_response("plugins.ext", {
"modules" : modules,
})
else:
#Relay Template Variables
return render_to_response(request.META['HTTP_REFERER'].split('/')[3] + ".ext", {
"status" : status,
})
0
Example 27
Project: splunk-webframework Source File: views.py
@staff_member_required
def model_detail(request, app_label, model_name):
if not utils.docutils_is_available:
return missing_docutils_page(request)
# Get the model class.
try:
app_mod = models.get_app(app_label)
except ImproperlyConfigured:
raise Http404(_("App %r not found") % app_label)
model = None
for m in models.get_models(app_mod):
if m._meta.object_name.lower() == model_name:
model = m
break
if model is None:
raise Http404(_("Model %(model_name)r not found in app %(app_label)r") % {'model_name': model_name, 'app_label': app_label})
opts = model._meta
# Gather fields/field descriptions.
fields = []
for field in opts.fields:
# ForeignKey is a special case since the field will actually be a
# descriptor that returns the other object
if isinstance(field, models.ForeignKey):
data_type = field.rel.to.__name__
app_label = field.rel.to._meta.app_label
verbose = utils.parse_rst((_("the related `%(app_label)s.%(data_type)s` object") % {'app_label': app_label, 'data_type': data_type}), 'model', _('model:') + data_type)
else:
data_type = get_readable_field_data_type(field)
verbose = field.verbose_name
fields.append({
'name': field.name,
'data_type': data_type,
'verbose': verbose,
'help_text': field.help_text,
})
# Gather many-to-many fields.
for field in opts.many_to_many:
data_type = field.rel.to.__name__
app_label = field.rel.to._meta.app_label
verbose = _("related `%(app_label)s.%(object_name)s` objects") % {'app_label': app_label, 'object_name': data_type}
fields.append({
'name': "%s.all" % field.name,
"data_type": 'List',
'verbose': utils.parse_rst(_("all %s") % verbose , 'model', _('model:') + opts.module_name),
})
fields.append({
'name' : "%s.count" % field.name,
'data_type' : 'Integer',
'verbose' : utils.parse_rst(_("number of %s") % verbose , 'model', _('model:') + opts.module_name),
})
# Gather model methods.
for func_name, func in model.__dict__.items():
if (inspect.isfunction(func) and len(inspect.getargspec(func)[0]) == 1):
try:
for exclude in MODEL_METHODS_EXCLUDE:
if func_name.startswith(exclude):
raise StopIteration
except StopIteration:
continue
verbose = func.__doc__
if verbose:
verbose = utils.parse_rst(utils.trim_docstring(verbose), 'model', _('model:') + opts.module_name)
fields.append({
'name': func_name,
'data_type': get_return_data_type(func_name),
'verbose': verbose,
})
# Gather related objects
for rel in opts.get_all_related_objects() + opts.get_all_related_many_to_many_objects():
verbose = _("related `%(app_label)s.%(object_name)s` objects") % {'app_label': rel.opts.app_label, 'object_name': rel.opts.object_name}
accessor = rel.get_accessor_name()
fields.append({
'name' : "%s.all" % accessor,
'data_type' : 'List',
'verbose' : utils.parse_rst(_("all %s") % verbose , 'model', _('model:') + opts.module_name),
})
fields.append({
'name' : "%s.count" % accessor,
'data_type' : 'Integer',
'verbose' : utils.parse_rst(_("number of %s") % verbose , 'model', _('model:') + opts.module_name),
})
return render_to_response('admin_doc/model_detail.html', {
'root_path': urlresolvers.reverse('admin:index'),
'name': '%s.%s' % (opts.app_label, opts.object_name),
'summary': _("Fields on %s objects") % opts.object_name,
'description': model.__doc__,
'fields': fields,
}, context_instance=RequestContext(request))
0
Example 28
Project: classic.rhizome.org Source File: admin.py
def url_inventory(self, request):
'''
creates a csv file compiling the http status of artbase artworks and their urls and locations
'''
context_instance = RequestContext(request)
opts = self.model._meta
admin_site = self.admin_site
completed_message = None
writer = csv.writer(open(os.path.join(settings.MEDIA_ROOT, "artbase/data/artbase_broken_urls_inventory_%s.csv" \
% datetime.date.today(), "wb")))
writer.writerow(['ARTWORK ID', 'ARTWORK TITLE', 'ARTWORK URL', 'URL STATUS', 'LOCATION', 'LOCATION STATUS','UPDATE NOTICE'])
all_works = ArtworkStub.objects.filter(status="approved")
handler = urllib2.UnknownHandler()
opener = urllib2.build_opener(handler)
urllib2.install_opener(opener)
# timeout in seconds
timeout = 15
socket.setdefaulttimeout(timeout)
if request.method == "POST":
if request.POST.get("run_inventory"):
for work in all_works:
url_response = None
url_error_msg = None
url_status = None
location_response = None
location_status = None
location_error_msg = None
updating_notice = None
#a few hacks to make sure the url is formatted correctly
if "/artbase/" in work.url:
if "http://archive.rhizome.org" not in work.url:
if "http://" not in work.url:
work.url = "http://archive.rhizome.org%s" % work.url
updating_notice = "Make sure has full rhizome archives url (http://archive.rhizome.org/....)"
if "/artbase/" in work.location:
if "http://archive.rhizome.org" not in work.location:
if "http://" not in work.location:
work.location = "http://archive.rhizome.org%s" % work.location
updating_notice = "Make sure has full rhizome archives url (http://archive.rhizome.org/....)"
if "http://" not in work.url:
work.url = "http://%s" % work.url
updating_notice = "Make sure has url including 'http://'"
if "http://" not in work.location:
work.location = "http://%s" % work.location
updating_notice = "Make sure has url including 'http://'"
try:
url_response = urllib2.urlopen(work.url, timeout = 15)
except (urllib2.URLError, httplib.BadStatusLine, httplib.InvalidURL, httplib.HTTPException,httplib.UnknownProtocol), e:
if hasattr(e, 'reason'):
if isinstance(e.reason, socket.timeout):
url_error_msg = 'Failed to reach server. TIMED OUT '
else:
url_error_msg = 'Failed to reach server. Reason: %s ' % e.reason
elif hasattr(e, 'code'):
url_error_msg = "The server couldn't fulfill the request. Error code: %s" % e.code
else:
url_error_msg = "Failed to reach server!"
except:
url_error_msg = "Failed to reach server!"
if url_response:
url_status = "SUCCESS"
else:
url_status = url_error_msg
if work.location:
try:
location_response = urllib2.urlopen(work.location, timeout = 15)
except (urllib2.URLError, httplib.BadStatusLine, httplib.InvalidURL, \
httplib.HTTPException,httplib.UnknownProtocol), e:
if hasattr(e, 'reason'):
if isinstance(e.reason, socket.timeout):
url_error_msg = 'Failed to reach server. TIMED OUT '
else:
location_error_msg = 'Failed to reach a server. Reason: %s ' % e.reason
elif hasattr(e, 'code'):
location_error_msg = "The server couldn't fulfill the request. Error code: %s" % e.code
else:
location_error_msg = "Failed to reach server!"
if location_response:
location_status = "SUCCESS"
else:
location_status = location_error_msg
if location_error_msg or url_error_msg and not updating_notice:
updating_notice = "This work has broken links"
if updating_notice:
writer.writerow([
"%s" % work.id,
"%s" % work.title,
"%s" % work.url,
"%s" % url_status,
"%s" % work.location,
"%s" % location_status,
"%s" % updating_notice,
])
report_email = EmailMessage('ArtBase Broken URLs Inventory Report', 'Report Attached.', settings.ARTBASE_GROUP_EMAIL,
[settings.ARTBASE_GROUP_EMAIL], headers = {'Reply-To': settings.ARTBASE_GROUP_EMAIL})
report_email.attach('artbase_broken_urls_inventory_%s.csv' % datetime.date.today(), writer, 'text/csv')
report_email.send()
completed_message = True
d = {'admin_site': admin_site.name,
'title': "Inventory Broken Artwork URLS",
'opts': "Artworks",
'app_label': opts.app_label,
"completed_message":completed_message
}
return render_to_response('admin/artbase/url_inventory.html', d, context_instance)
0
Example 29
Project: tendenci Source File: views.py
def index(request, form_class=SubmitContactForm, template_name="form.html"):
if request.method == "GET":
# event-log view
EventLog.objects.log(instance=Contact(), action='viewed')
if request.method == "POST":
event_log_dict = {}
form = form_class(request.POST)
if form.is_valid():
email = form.cleaned_data.get('email')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
if listed_in_email_block(email):
# listed in the email blocks - it's a spam email we want to block
# log the spam
EventLog.objects.log()
# redirect normally so they don't suspect
return HttpResponseRedirect(reverse('form.confirmation'))
address = form.cleaned_data.get('address')
city = form.cleaned_data.get('city')
state = form.cleaned_data.get('state')
zipcode = form.cleaned_data.get('zipcode')
country = form.cleaned_data.get('country')
phone = form.cleaned_data.get('phone')
url = form.cleaned_data.get('url')
message = form.cleaned_data.get('message')
exists = User.objects.filter(
first_name__iexact=first_name,
last_name__iexact=last_name,
email__iexact=email,
).exists()
if request.user.is_anonymous():
username = first_name.replace(' ', '')
if last_name:
username = username + '_' + last_name.replace(' ', '')
username = username.lower()
try:
User.objects.get(username=username)
x = User.objects.filter(first_name=first_name).count()
username = username + '_' + unicode(x)
except User.DoesNotExist:
pass
contact_user = User(
username=username,
email=email,
first_name=first_name,
last_name=last_name,
)
contact_user.is_active = False
contact_user.save()
profile = Profile(user=contact_user, owner=contact_user, creator=User.objects.get(pk=1),
address=address, country=country, city=city, state=state,
url=url, phone=phone, zipcode=zipcode)
profile.save()
sf_id = create_salesforce_contact(profile)
# if exists:
# event_log_dict['description'] = 'logged-out submission as existing user'
# else:
event_log_dict['description'] = 'logged-out submission as new user'
else: # logged in user
self_submit = all([
request.user.first_name.lower().strip() == first_name.lower().strip(),
request.user.last_name.lower().strip() == last_name.lower().strip(),
request.user.email.lower().strip() == email.lower().strip(),
])
contact_user = request.user
if exists:
if self_submit:
event_log_dict['description'] = 'logged-in submission as self'
else:
event_log_dict['description'] = 'logged-in submission as existing user'
else:
event_log_dict['description'] = 'logged-in submission as non-existing user'
contact_kwargs = {
'first_name': first_name,
'last_name': last_name,
'message': message,
'user': contact_user,
}
contact = Contact(**contact_kwargs)
contact.allow_anonymous_view = False
contact.save()
if address or city or state or zipcode or country:
address_kwargs = {
'address': address,
'city': city,
'state': state,
'zipcode': zipcode,
'country': country,
}
obj_address = Address(**address_kwargs)
obj_address.save() # saves object
contact.addresses.add(obj_address) # saves relationship
if phone:
obj_phone = Phone(number=phone)
obj_phone.save() # saves object
contact.phones.add(obj_phone) # saves relationship
if email:
obj_email = Email(email=email)
obj_email.save() # saves object
contact.emails.add(obj_email) # saves relationship
if url:
obj_url = URL(url=url)
obj_url.save() # saves object
contact.urls.add(obj_url) # saves relationship
site_name = get_setting('site', 'global', 'sitedisplayname')
message_link = get_setting('site', 'global', 'siteurl')
# send notification to administrators
# get admin notice recipients
recipients = get_notice_recipients('module', 'contacts', 'contactrecipients')
if recipients:
if notification:
extra_context = {
'reply_to': email,
'contact': contact,
'first_name': first_name,
'last_name': last_name,
'address': address,
'city': city,
'state': state,
'zipcode': zipcode,
'country': country,
'phone': phone,
'email': email,
'url': url,
'message': message,
'message_link': message_link,
'site_name': site_name,
}
notification.send_emails(recipients, 'contact_submitted', extra_context)
# event-log (logged in)
event_log = EventLog.objects.log(
instance=contact,
user=contact_user,
action='submitted',
**event_log_dict
)
event_log.url = contact.get_absolute_url()
event_log.save()
return HttpResponseRedirect(reverse('form.confirmation'))
else:
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
form = form_class()
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
0
Example 30
Project: virtmgr Source File: views.py
def index(request, host_id):
if not request.user.is_authenticated():
return HttpResponseRedirect('/user/login')
kvm_host = Host.objects.get(user=request.user.id, id=host_id)
def add_error(msg, type_err):
error_msg = Log(host_id=host_id,
type=type_err,
message=msg,
user_id=request.user.id
)
error_msg.save()
if not kvm_host.login or not kvm_host.passwd:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = request.session['login_kvm']
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = request.session['passwd_kvm']
else:
return -1
return 0
else:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = kvm_host.login
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = kvm_host.passwd
else:
return -1
return 0
def vm_conn():
flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE]
auth = [flags, creds, None]
uri = 'qemu+tcp://' + kvm_host.ipaddr + '/system'
try:
conn = libvirt.openAuth(uri, auth, 0)
return conn
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_all_vm():
try:
vname = {}
for id in conn.listDomainsID():
id = int(id)
dom = conn.lookupByID(id)
vname[dom.name()] = dom.info()[0]
for id in conn.listDefinedDomains():
dom = conn.lookupByName(id)
vname[dom.name()] = dom.info()[0]
return vname
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_all_stg():
try:
storages = []
for name in conn.listStoragePools():
storages.append(name)
for name in conn.listDefinedStoragePools():
storages.append(name)
return storages
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_all_net():
try:
networks = []
for name in conn.listNetworks():
networks.append(name)
for name in conn.listDefinedNetworks():
networks.append(name)
# Not support all distro but Fedora!!!
#for ifcfg in conn.listInterfaces():
# if ifcfg != 'lo' and not re.findall("eth", ifcfg):
# networks.append(ifcfg)
#for ifcfg in conn.listDefinedInterfaces():
# if ifcfg != 'lo' and not re.findall("eth", ifcfg):
# networks.append(ifcfg)
return networks
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def find_all_iso():
try:
iso = []
for storage in storages:
stg = conn.storagePoolLookupByName(storage)
stg.refresh(0)
for img in stg.listVolumes():
if re.findall(".iso", img) or re.findall(".ISO", img):
iso.append(img)
return iso
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def find_all_img():
try:
disk = []
for storage in storages:
stg = conn.storagePoolLookupByName(storage)
stg.refresh(0)
for img in stg.listVolumes():
if re.findall(".img", img) or re.findall(".IMG", img):
disk.append(img)
return disk
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_img_path(vol):
try:
for storage in storages:
stg = conn.storagePoolLookupByName(storage)
for img in stg.listVolumes():
if vol == img:
vl = stg.storageVolLookupByName(vol)
return vl.path()
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_img_format(vol):
try:
for storage in storages:
stg = conn.storagePoolLookupByName(storage)
for img in stg.listVolumes():
if vol == img:
vl = stg.storageVolLookupByName(vol)
xml = vl.XMLDesc(0)
format = util.get_xml_path(xml, "/volume/target/format/@type")
return format
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_cpus():
try:
return conn.getInfo()[2]
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_mem():
try:
return conn.getInfo()[1]
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_emulator():
try:
emulator = []
xml = conn.getCapabilities()
arch = conn.getInfo()[0]
if arch == 'x86_64':
emulator.append(util.get_xml_path(xml,"/capabilities/guest[1]/arch/emulator"))
emulator.append(util.get_xml_path(xml,"/capabilities/guest[2]/arch/emulator"))
else:
emulator = util.get_xml_path(xml,"/capabilities/guest/arch/emulator")
return emulator
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_machine():
try:
xml = conn.getCapabilities()
machine = util.get_xml_path(xml,"/capabilities/guest/arch/machine/@canonical")
return machine
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def create_volume(stg_pool, img, size_max):
try:
size_max = int(size_max) * 1073741824
xml = """
<volume>
<name>%s.img</name>
<capacity>%s</capacity>
<allocation>0</allocation>
<target>
<format type='qcow2'/>
</target>
</volume>""" % (img, size_max)
stg = conn.storagePoolLookupByName(stg_pool)
stg.createXML(xml,0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def add_vm(name, mem, cpus, machine, emul, img, iso, bridge):
try:
arch = conn.getInfo()[0]
if not iso:
iso = ''
memaloc = mem
xml = """<domain type='kvm'>
<name>%s</name>
<memory>%s</memory>
<currentMemory>%s</currentMemory>
<vcpu>%s</vcpu>
<os>
<type arch='%s' machine='%s'>hvm</type>
<boot dev='hd'/>
<boot dev='cdrom'/>
<bootmenu enable='yes'/>
</os>
<features>
<acpi/>
<apic/>
<pae/>
</features>
<clock offset='utc'/>
<on_poweroff>destroy</on_poweroff>
<on_reboot>restart</on_reboot>
<on_crash>restart</on_crash>
<devices>""" % (name, mem, memaloc, cpus, arch, machine)
if arch == 'x86_64':
xml += """<emulator>%s</emulator>""" % (emul[1])
else:
xml += """<emulator>%s</emulator>""" % (emul)
xml += """<disk type='file' device='disk'>
<driver name='qemu' type='qcow2'/>
<source file='%s'/>
<target dev='hda' bus='ide'/>
</disk>
<disk type='file' device='cdrom'>
<driver name='qemu' type='raw'/>
<source file='%s'/>
<target dev='hdc' bus='ide'/>
<readonly/>
</disk>
<controller type='ide' index='0'>
<address type='pci' domain='0x0000' bus='0x00' slot='0x01' function='0x1'/>
</controller>
""" % (img, iso)
if re.findall("br", bridge):
xml += """<interface type='bridge'>
<source bridge='%s'/>""" % (bridge)
else:
xml += """<interface type='network'>
<source network='%s'/>""" % (bridge)
xml += """<address type='pci' domain='0x0000' bus='0x00' slot='0x03' function='0x0'/>
</interface>
<input type='tablet' bus='usb'/>
<input type='mouse' bus='ps2'/>
<graphics type='vnc' port='-1' autoport='yes'/>
<video>
<model type='cirrus' vram='9216' heads='1'/>
<address type='pci' domain='0x0000' bus='0x00' slot='0x02' function='0x0'/>
</video>
<memballoon model='virtio'>
<address type='pci' domain='0x0000' bus='0x00' slot='0x05' function='0x0'/>
</memballoon>
</devices>
</domain>"""
conn.defineXML(xml)
dom = conn.lookupByName(name)
dom.setAutostart(1)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
conn = vm_conn()
if conn == "error":
return HttpResponseRedirect('/overview/' + host_id + '/')
errors = []
cores = get_cpus()
all_vm = get_all_vm()
storages = get_all_stg()
all_iso = find_all_iso()
all_img = find_all_img()
if all_iso is "error" or all_img is "error":
msg = _('Storage pools are not available or are not active')
errors.append(msg)
bridge = get_all_net()
if bridge == "error":
msg = _('Network pools are not available or are not active')
errors.append(msg)
emul = get_emulator()
machine = get_machine()
addmem = get_mem()
cpus = []
for cpu in range(1,cores+1):
cpus.append(cpu)
if request.method == 'POST':
name = request.POST.get('name','')
setmem = request.POST.get('memory','')
cpus = request.POST.get('cpus','')
iso = request.POST.get('iso','')
img = request.POST.get('img','')
netbr = request.POST.get('bridge','')
setmem = int(setmem) * 1024
hdd = get_img_path(img)
cdrom = get_img_path(iso)
hdd_frmt = get_img_format(img)
simbol = re.search('[^a-zA-Z0-9\_]+', name)
if name in all_vm:
msg = _('This is the name of the virtual machine already exists')
errors.append(msg)
if len(name) > 20:
msg = _('The name of the virtual machine must not exceed 20 characters')
errors.append(msg)
if simbol:
msg = _('The name of the virtual machine must not contain any characters and Russian characters')
errors.append(msg)
if not request.POST.get('hdd','') and not img or img == 'error':
msg = _('Images of the HDD to a virtual machine not available. You need to create an HDD image')
errors.append(msg)
if not name:
msg = _('Enter the name of the virtual machine')
errors.append(msg)
if not errors:
if request.POST.get('hdd',''):
size = request.POST.get('hdd','')
stg_pool = request.POST.get('stg_pool','')
create_volume(stg_pool, name, size)
img = name + '.img'
hdd = get_img_path(img)
if add_vm(name, setmem, cpus, machine, emul, hdd, cdrom, netbr) is 'error':
msg = _('Hardware acceleration is not found')
errors.append(msg)
else:
msg = _('Creating a virtual machine: ')
msg = msg + name
add_error(msg,'user')
return HttpResponseRedirect('/vm/%s/%s/' % (host_id, name))
conn.close()
return render_to_response('newvm.html', locals())
0
Example 31
Project: tendenci Source File: views.py
@permission_required('theme_editor.change_themefileversion')
def edit_file(request, form_class=FileForm, template_name="theme_editor/index.html"):
if not has_perm(request.user, 'theme_editor.view_themefileversion'):
raise Http403
selected_theme = request.GET.get("theme_edit", get_theme())
original_theme_root = os.path.join(settings.ORIGINAL_THEMES_DIR, selected_theme)
if settings.USE_S3_THEME:
theme_root = os.path.join(settings.THEME_S3_PATH, selected_theme)
else:
theme_root = os.path.join(settings.ORIGINAL_THEMES_DIR, selected_theme)
# get the default file and clean up any input
default_file = request.GET.get("file", DEFAULT_FILE)
if default_file:
default_file = default_file.replace('\\', '/')
default_file = default_file.strip('/')
default_file = default_file.replace('////', '/')
default_file = default_file.replace('///', '/')
default_file = default_file.replace('//', '/')
is_file = qstr_is_file(default_file, ROOT_DIR=theme_root)
is_dir = qstr_is_dir(default_file, ROOT_DIR=theme_root)
if is_file:
pass
elif is_dir:
# if default_file is a directory then append the
# trailing slash so we can get the dirname below
default_file = '%s/' % default_file
else:
# if the default_file is not a directory or file within
# the themes folder then return a 404
raise Http404(_("Custom template not found. Make sure you've copied over the themes to the THEME_DIR."))
# get the current file name
current_file = os.path.basename(default_file)
# get file ext
name = current_file.split('/')[-1]
ext = name.split('.')[-1]
stylesheets = ['css', 'less']
# get the present working directory
# and make sure they cannot list root
pwd = os.path.dirname(default_file)
if pwd == '/':
pwd = ''
current_file_path = os.path.join(pwd, current_file)
# get the previous directory name and path
prev_dir = '/'
prev_dir_name = 'theme base'
pwd_split = pwd.split('/')
if len(pwd_split) > 1:
prev_dir_name = pwd_split[-2]
pwd_split.pop()
prev_dir = '/'.join(pwd_split)
elif not pwd_split[0]:
prev_dir = ''
# get the direcory list
dirs = get_dir_list(pwd, ROOT_DIR=theme_root)
# get the file list
files, non_editable_files = get_file_list(pwd, ROOT_DIR=theme_root)
all_files_folders = get_all_files_list(ROOT_DIR=theme_root)
# non-deletable files
non_deletable_files = ['homepage.html', 'default.html', 'footer.html', 'header.html', 'sidebar.html', 'nav.html', 'styles.less', 'styles.css']
# get the number of themes in the themes directory on the site
theme_choices = [ i for i in theme_choice_list()]
theme_count = len(theme_choices)
# get a list of revisions
archives = ThemeFileVersion.objects.filter(relative_file_path=default_file).order_by("-create_dt")
if request.is_ajax() and request.method == "POST":
file_form = form_class(request.POST)
response_status = 'FAIL'
response_message = _('Cannot update file.')
if file_form.is_valid():
if file_form.save(request, default_file, ROOT_DIR=theme_root, ORIG_ROOT_DIR=original_theme_root):
response_status = 'SUCCESS'
response_message = unicode(_('Your changes have been saved.'))
EventLog.objects.log()
response = json.dumps({'status':response_status, 'message':response_message})
return HttpResponse(response, content_type="application/json")
content = get_file_content(default_file, ROOT_DIR=theme_root)
file_form = form_class({"content": content, "rf_path": default_file})
theme_form = ThemeSelectForm(initial={'theme_edit': selected_theme})
return render_to_response(template_name, {
'file_form': file_form,
'theme_form': theme_form,
'current_theme': selected_theme,
'current_file_path': current_file_path,
'current_file': current_file,
'prev_dir_name': prev_dir_name,
'prev_dir': prev_dir,
'pwd': pwd,
'dirs': dirs,
'files': files,
'non_editable_files': non_editable_files,
'non_deletable_files': non_deletable_files,
'theme_count': theme_count,
'archives': archives,
'is_file': is_file,
'is_dir': is_dir,
'all_files_folders': all_files_folders,
'ext' : ext,
'stylesheets' : stylesheets
}, context_instance=RequestContext(request))
0
Example 32
def create_profile(request, form_class, success_url=None,
template_name='profiles/private/create_profile.html',
extra_context=None):
"""
Create a profile for the current user, if one doesn't already
exist.
If the user already has a profile, a redirect will be issued to the
:view:`profiles.views.edit_profile` view.
**Optional arguments:**
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context.
``form_class``
The form class to use for validating and creating the user
profile. This form class must define a method named
``save()``, implementing the same argument signature as the
``save()`` method of a standard Django ``ModelForm`` (this
view will call ``save(commit=False)`` to obtain the profile
object, and fill in the user before the final save). If the
profile object includes many-to-many relations, the convention
established by ``ModelForm`` of using a method named
``save_m2m()`` will be used, and so your form class should
also define this method.
``success_url``
The URL to redirect to after successful profile creation. If
this argument is not supplied, this will default to the URL of
:view:`profiles.views.profile_detail` for the newly-created
profile object.
``template_name``
The template to use when displaying the profile-creation
form. If not supplied, this will default to
:template:`profiles/create_profile.html`.
**Context:**
``form``
The profile-creation form.
**Template:**
``template_name`` keyword argument, or
:template:`profiles/create_profile.html`.
"""
try:
profile_obj = request.user.profile
return HttpResponseRedirect(reverse('profiles_edit_profile'))
except ObjectDoesNotExist:
pass
#
# We set up success_url here, rather than as the default value for
# the argument. Trying to do it as the argument's default would
# mean evaluating the call to reverse() at the time this module is
# first imported, which introduces a circular dependency: to
# perform the reverse lookup we need access to profiles/urls.py,
# but profiles/urls.py in turn imports this module.
#
if success_url is None:
success_url = reverse('profiles_profile_detail',
kwargs={'username': request.user.username})
if request.method == 'POST':
form = form_class(data=request.POST, files=request.FILES)
if form.is_valid():
profile_obj = form.save(commit=False)
profile_obj.user = request.user
profile_obj.save()
if hasattr(form, 'save_m2m'):
form.save_m2m()
return HttpResponseRedirect(success_url)
else:
form = form_class()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{'form': form},
context_instance=context)
0
Example 33
Project: hubplus Source File: views.py
@secure_resource(TgGroup)
def group(request, group, template_name="plus_groups/group.html", current_app='plus_groups', **kwargs):
if not group :
raise Http404(_('There is no group with this id'))
user = request.user
can_join = False
apply = False
leave = False
invite = False
can_comment = False
message = False
add_link = False
can_tag = False
can_change_avatar = False
has_accept = False
can_delete = False
is_following = Following.objects.is_following(request.user, group.get_inner())
editable_group_type = group.group_type != settings.GROUP_HUB_TYPE
if user.is_authenticated():
if user.is_direct_member_of(group.get_inner()):
# can now leave group if you aren't the last one out
if group.get_no_members() > 1 :
leave = True
try :
group.invite_member
invite = True
except Exception, e :# user doesn't have invite permission
pass
else :
try :
group.join
can_join = True
except Exception, e: # user doesn't have join permission
pass
try :
if not can_join :
group.apply
apply = True
except Exception, e : # user doesn't have apply permission
pass
try :
group.comment
can_comment = True
can_tag = True # XXX commentor interface governs who can tag. Do we need a special tag interface?
except :
pass
try :
group.message_members
message = True
except :
pass
try :
group.create_Link
add_link = True
except Exception, e :
print e
pass
try :
group.change_avatar
can_change_avatar = True
except Exception, e:
pass
try :
dummy = group.delete
can_delete = True
except :
pass
if has_access(request.user, None, 'Application.Accept', group._inner.get_security_context()):
has_accept = True
else:
has_accept = False
tweets = FeedItem.feed_manager.get_from_permissioned(group, request.user)
try:
group.get_all_sliders
perms_bool = True
except PlusPermissionsNoAccessException:
perms_bool = False
if kwargs['type'] == 'hub':
type_name = hub_name()
else:
type_name = "Group"
search_types = narrow_search_types(type_name)
side_search = side_search_args(current_app + ':groups', search_types[0][1][2])
search = request.GET.get('search', '')
order = request.GET.get('order', '')
resource_search = resources(group=group, search=search, order=order)
resource_listing_args = listing_args(current_app + ':group_resources', current_app + ':group_resources_tag', tag_string='', search_terms=search, multitabbed=False, order=order, template_base='plus_lib/listing_frag.html', search_type_label='resources')
resource_listing_args['group_id'] = group.id
##############Here we should use the "plus_search" function from plus_explore as above########
member_search = a_member_search(group=group, search=search, order=order,
member_profile_ids=[x.get_profile().get_ref().id for x in group.users.all()])
host_search = a_member_search(group=group.get_admin_group(), search=search, order=order,
member_profile_ids=[x.get_profile().get_ref().id for x in group.get_admin_group().users.all()])
member_listing_args = listing_args(current_app+':group_members', current_app+':group_members_tag', tag_string='', search_terms=search, multitabbed=False, order=order, template_base='plus_lib/listing_frag.html', search_type_label='members', group_id=group.id)
host_listing_args = listing_args(current_app+':group_hosts', current_app+':group_hosts_tag', tag_string='', search_terms=search, multitabbed=False, order=order, template_base='plus_lib/listing_frag.html', search_type_label='hosts', group_id=group.id)
member_count = group.users.all().count()
host_count = group.get_admin_group().users.all().count()
##############################################################################################
return render_to_response(template_name, {
"head_title" : "%s" % group.get_display_name(),
"status_type" : 'group',
#"status_since" : status_since,
"group" : TemplateSecureWrapper(group),
"target_class" : ContentType.objects.get_for_model(group.get_inner()).id,
"target_id" : group.get_inner().id,
#"members" : members,
"member_count" : member_count,
"leave": leave,
"can_join" : can_join,
"apply" : apply,
"invite" : invite,
"can_comment" : can_comment,
"message" : message,
"add_link" : add_link,
"can_tag" : can_tag,
"can_change_avatar" : can_change_avatar,
"can_delete" : can_delete,
"is_following" : is_following,
#"hosts": hosts,
"host_group_id":group.get_admin_group().id,
"host_group_app_label":group.get_admin_group().group_app_label() + ':group',
"is_host":user.is_admin_of(group.get_inner()),
"host_count": host_count,
"tweets" : tweets,
"permissions": perms_bool,
'side_search_args':side_search,
'resource_search':resource_search,
'resource_listing_args':resource_listing_args,
'member_search':member_search,
'member_listing_args':member_listing_args,
'host_search':host_search,
'host_listing_args':host_listing_args,
'group_id':group.id,
'search_types':search_types,
'tagged_url':current_app + ':groups_tag',
'has_accept':has_accept,
'editable_group_type':editable_group_type,
}, context_instance=RequestContext(request, current_app=current_app)
)
0
Example 34
@login_required
def add(request):
feed_repo_form = FeedRepositoryForm()
cloned_repo_form = ClonedRepositoryForm()
project_form = ProjectForm()
blog_form = BlogForm()
form_keys = {
1: ('title', 'description', 'website', 'wiki'),
2: ('web_url', 'clone_url', 'vcs', 'repo_rss', 'cmd'),
3: ('url', 'rss')
}
if 'current' in request.POST:
current = int(request.POST['current'])
else:
current = 0
if current == 1:
project_form = ProjectForm(request.POST)
if not project_form.is_valid():
current -= 1
elif current == 2:
if 'clone_url' in request.POST:
cloned_repo_form = ClonedRepositoryForm(request.POST)
if not cloned_repo_form.is_valid():
current -= 1
elif 'repo_rss' in request.POST:
feed_repo_form = FeedRepositoryForm(request.POST)
if not feed_repo_form.is_valid():
current -= 1
elif current == 3:
blog_form = BlogForm(request.POST)
if not ('url' not in request.POST or blog_form.is_valid()):
current -= 1
# go to the next form
current += 1
# if there are more parts to the form
if current < 4:
# remove the csrf token and current from a copy of the POST data
post = request.POST.copy()
if 'csrfmiddlewaretoken' in post:
post.pop('csrfmiddlewaretoken')
post.pop('current')
# remove any of the keys that should be set on this form page
for key in form_keys[current]:
try:
post.pop(key)
except:
pass
return render_to_response('projects/add.html', {
'parts': [1, 2, 3],
'current': current,
'previous_data': post,
'cloned_repo_form': cloned_repo_form,
'feed_repo_form': feed_repo_form,
'project_form': project_form,
'blog_form': blog_form,
'js_page_id': 'add_project'
}, context_instance = RequestContext(request))
# otherwise, if the form is complete, create the project
else:
# validate and clean all forms
project_form = ProjectForm(request.POST)
cloned_repo_form = ClonedRepositoryForm(request.POST)
feed_repo_form = FeedRepositoryForm(request.POST)
blog_form = BlogForm(request.POST)
for form in [project_form, cloned_repo_form, feed_repo_form, blog_form]:
form.is_valid()
# create the blog object
if 'rss' in request.POST:
blog = Blog(url = blog_form.cleaned_data['url'],
rss = blog_form.cleaned_data['rss'],
from_feed = True)
else:
blog = Blog(from_feed = False)
blog.save()
# create the repository object
# if using google code removes read only addition
# if git@ is mistakenly typed, git:// is placed in
if 'clone_url' in request.POST:
url = cloned_repo_form.cleaned_data['clone_url']
gitfix = url.replace('git@', 'git://')
url = gitfix
if "google.com" in url:
split = url.split(' ')
url = split[0]
repo = Repository(web_url = cloned_repo_form.cleaned_data['web_url'],
clone_url = url,
from_feed = False)
else:
repo = Repository(web_url = feed_repo_form.cleaned_data['web_url'],
repo_rss = feed_repo_form.cleaned_data['repo_rss'],
from_feed = True)
repo.save()
# create the project object
project = Project(title = project_form.cleaned_data['title'],
website = project_form.cleaned_data['website'],
wiki = project_form.cleaned_data['wiki'],
description = project_form.cleaned_data['description'],
active = True,
repository_id = repo.id,
blog_id = blog.id,
pending = True)
# get the project a primary key
project.save()
# associate the current user with the project as an author
project.authors.add(request.user)
# save the project again
project.save()
# Set the active flag as true
project.active = True
# Save the project again
project.save()
# redirect to the show page for the new project
return HttpResponseRedirect(reverse(show, args = (project.url_path,)))
0
Example 35
Project: transifex Source File: views.py
@login_required
def translate(request, project_slug, lang_code, resource_slug=None,
*args, **kwargs):
"""
Main lotte view.
"""
# Permissions handling
# Project should always be available
project = get_object_or_404(Project, slug=project_slug)
team = Team.objects.get_or_none(project, lang_code)
check = ProjectPermission(request.user)
if not check.submit_translations(team or project) and not\
check.maintain(project):
return permission_denied(request)
resources = []
if resource_slug:
resource_list = [get_object_or_404(Resource, slug=resource_slug,
project=project)]
else:
resource_list = Resource.objects.filter(project=project)
# Return a page explaining that the project has multiple source langs and
# cannot be translated as a whole.
if resource_list.values('source_language').distinct().count() > 1:
messages.info(request,_(
"There are multiple source languages for this project. "
"You will only be able to translate resources for one "
"source language at a time."))
return HttpResponseRedirect(reverse('project_detail',
args=[project_slug]),)
# Filter resources that are not accepting translations
for resource in resource_list:
if resource.accept_translations:
resources.append(resource)
# If no resource accepting translations, raise a 403
if not resources:
return permission_denied(request)
target_language = Language.objects.by_code_or_alias_or_404(lang_code)
# If it is an attempt to edit the source language, redirect the user to
# resource_detail and show him a message explaining the reason.
if target_language == get_source_language(resources):
messages.error(request,_(
"Cannot edit the source language because this would "
"result in translation mismatches! If you want to "
"update the source strings consider using the transifex "
"command-line client."))
if resource_slug:
return HttpResponseRedirect(reverse('resource_detail',
args=[project_slug,
resource_slug]),)
else:
return HttpResponseRedirect(reverse('project_detail',
args=[project_slug]),)
total_strings = SourceEntity.objects.filter(
resource__in = resources).count()
translated_strings = Translation.objects.filter(
resource__in=resources,
language=target_language,
source_entity__pluralized=False,
rule=5).count()
reviewed_strings = Translation.objects.filter(
resource__in=resources,
language=target_language,
source_entity__pluralized=False,
rule=5,
reviewed=True).count()
# Include counting of pluralized entities
for pluralized_entity in SourceEntity.objects.filter(resource__in = resources,
pluralized=True):
plurals_translated = Translation.objects.filter(
language=target_language,
source_entity=pluralized_entity).count()
if plurals_translated == len(target_language.get_pluralrules()):
translated_strings += 1
if len(resources) > 1:
translation_resource = None
else:
translation_resource = resources[0]
contributors = User.objects.filter(pk__in=Translation.objects.filter(
resource__in = resources,
language = target_language,
rule = 5).values_list("user", flat=True))
lotte_init.send(None, request=request, resources=resources,
language=target_language)
if target_language in [team.language for team in project.available_teams]:
team_language = True
else:
team_language = False
GtModel = get_model('gtranslate', 'Gtranslate')
try:
auto_translate = GtModel.objects.get(project=project)
except GtModel.DoesNotExist:
auto_translate = None
"""
if cache.get('lotte_%s' % request.session.session_key, None):
cache.delete('lotte_%s' % request.session.session_key)
"""
#Set rtl to True if target_language is an RTL language
rtl = False
if target_language.code in settings.RTL_LANGUAGE_CODES:
rtl = True
return render_to_response("translate.html", {
'project': project,
'resource': translation_resource,
'target_language': target_language,
'translated_strings': translated_strings,
'reviewed_strings': reviewed_strings,
'untranslated_strings': total_strings - translated_strings,
'contributors': contributors,
'resources': resources,
'resource_slug': resource_slug,
'languages': Language.objects.all(),
'auto_translate': auto_translate,
'spellcheck_supported_langs': SPELLCHECK_SUPPORTED_LANGS,
'team_language': team_language,
'RTL': rtl,
}, context_instance = RequestContext(request))
0
Example 36
Project: snowy Source File: admin.py
def render_revision_form(self, request, obj, version, revision, context, template, redirect_url):
"""Renders the object revision form."""
model = self.model
opts = model._meta
object_id = obj.pk
ordered_objects = opts.get_ordered_objects()
app_label = opts.app_label
object_version = version.object_version
ModelForm = self.get_form(request, obj)
formsets = []
if request.method == "POST":
form = ModelForm(request.POST, request.FILES, instance=obj)
if form.is_valid():
form_validated = True
new_object = self.save_form(request, form, change=True)
else:
form_validated = False
new_object = obj
for FormSet in self.get_formsets(request, new_object):
formset = FormSet(request.POST, request.FILES,
instance=new_object)
formsets.append(formset)
if all_valid(formsets) and form_validated:
self.save_model(request, new_object, form, change=True)
form.save_m2m()
for formset in formsets:
self.save_formset(request, form, formset, change=True)
change_message = _(u"Reverted to previous version, saved on %(datetime)s") % {"datetime": format(version.revision.date_created, _(settings.DATETIME_FORMAT))}
self.log_change(request, new_object, change_message)
self.message_user(request, _(u'The %(model)s "%(name)s" was reverted successfully. You may edit it again below.') % {"model": opts.verbose_name, "name": unicode(obj)})
return HttpResponseRedirect(redirect_url)
else:
initial = deserialized_model_to_dict(object_version, revision)
form = ModelForm(instance=obj, initial=initial)
for FormSet in self.get_formsets(request, obj):
formset = FormSet(instance=obj)
try:
attname = FormSet.fk.attname
except AttributeError:
# This is a GenericInlineFormset, or similar.
attname = FormSet.ct_fk_field_name
pk_name = FormSet.model._meta.pk.name
initial_overrides = dict([(getattr(version.object, pk_name), version) for version in revision if version.object.__class__ == FormSet.model and unicode(getattr(version.object, attname)) == unicode(object_id)])
initial = formset.initial
for initial_row in initial:
pk = initial_row[pk_name]
if pk in initial_overrides:
initial_row.update(deserialized_model_to_dict(initial_overrides[pk], revision))
del initial_overrides[pk]
else:
initial_row["DELETE"] = True
initial.extend([deserialized_model_to_dict(override, revision) for override in initial_overrides.values()])
# HACK: no way to specify initial values.
formset._total_form_count = len(initial)
formset.initial = initial
formset._construct_forms()
formsets.append(formset)
# Generate the context.
adminForm = admin.helpers.AdminForm(form, self.get_fieldsets(request, obj), self.prepopulated_fields)
media = self.media + adminForm.media
inline_admin_formsets = []
for inline, formset in zip(self.inline_instances, formsets):
fieldsets = list(inline.get_fieldsets(request, obj))
inline_admin_formset = admin.helpers.InlineAdminFormSet(inline, formset, fieldsets)
inline_admin_formsets.append(inline_admin_formset)
media = media + inline_admin_formset.media
context.update({"adminform": adminForm,
"object_id": obj.pk,
"original": obj,
"is_popup": False,
"media": mark_safe(media),
"inline_admin_formsets": inline_admin_formsets,
"errors": admin.helpers.AdminErrorList(form, formsets),
"root_path": self.admin_site.root_path,
"app_label": app_label,
"add": False,
"change": True,
"has_add_permission": self.has_add_permission(request),
"has_change_permission": self.has_change_permission(request, obj),
"has_delete_permission": self.has_delete_permission(request, obj),
"has_file_field": True, # FIXME - this should check if form or formsets have a FileField,
"has_absolute_url": hasattr(self.model, "get_absolute_url"),
"ordered_objects": ordered_objects,
"form_url": mark_safe(request.path),
"opts": opts,
"content_type_id": ContentType.objects.get_for_model(self.model).id,
"save_as": self.save_as,
"save_on_top": self.save_on_top,
"root_path": self.admin_site.root_path,})
return render_to_response(template, context, RequestContext(request))
0
Example 37
@login_required
def planning_table(request, member_id, list_type, from_date, to_date):
member = get_object_or_404(Party, pk=member_id)
role = "producer"
plan_type = "Production"
if member.is_customer():
role = "consumer"
plan_type = "Consumption"
try:
from_date = datetime.datetime(*time.strptime(from_date, '%Y_%m_%d')[0:5]).date()
to_date = datetime.datetime(*time.strptime(to_date, '%Y_%m_%d')[0:5]).date()
except ValueError:
raise Http404
# force from_date to Monday, to_date to Sunday
from_date = from_date - datetime.timedelta(days=datetime.date.weekday(from_date))
to_date = to_date - datetime.timedelta(days=datetime.date.weekday(to_date)+1)
to_date = to_date + datetime.timedelta(days=7)
products = None
if list_type == "M":
if role == "consumer":
products = CustomerProduct.objects.filter(customer=member, planned=True)
else:
products = ProducerProduct.objects.filter(producer=member, planned=True)
if not products:
products = Product.objects.filter(plannable=True)
list_type = "A"
plan_table = plan_weeks(member, products, from_date, to_date)
forms = create_weekly_plan_forms(plan_table.rows, data=request.POST or None)
if request.method == "POST":
#import pdb; pdb.set_trace()
for row in forms:
if row.formset.is_valid():
for form in row.formset.forms:
data = form.cleaned_data
qty = data['quantity']
plan_id = data['plan_id']
from_dt = data['from_date']
to_dt = data['to_date']
product_id = data['product_id']
plan = None
if plan_id:
# what if plan was changed by prev cell?
plan = ProductPlan.objects.get(id=plan_id)
if plan.to_date < from_dt or plan.from_date > to_dt:
plan = None
if qty:
if plan:
#import pdb; pdb.set_trace()
if not qty == plan.quantity:
#import pdb; pdb.set_trace()
if plan.from_date >= from_dt and plan.to_date <= to_dt:
plan.quantity = qty
plan.save()
else:
if plan.from_date < from_dt:
new_to_dt = from_dt - datetime.timedelta(days=1)
earlier_plan = ProductPlan(
member=plan.member,
product=plan.product,
quantity=plan.quantity,
from_date=plan.from_date,
to_date=new_to_dt,
role=plan.role,
inventoried=plan.inventoried,
distributor=plan.distributor,
)
earlier_plan.save()
if plan.to_date > to_dt:
new_plan = ProductPlan(
member=plan.member,
product=plan.product,
quantity=qty,
from_date=from_dt,
to_date=to_dt,
role=plan.role,
inventoried=plan.inventoried,
distributor=plan.distributor,
)
new_plan.save()
plan.from_date = to_dt + datetime.timedelta(days=1)
plan.save()
else:
plan.from_date=from_dt
plan.quantity=qty
plan.save()
else:
product = Product.objects.get(id=product_id)
new_plan = ProductPlan(
member=member,
product=product,
quantity=qty,
from_date=from_dt,
to_date=to_dt,
role=role,
#inventoried=True,
#distributor,
)
new_plan.save()
#import pdb; pdb.set_trace()
if role == "producer":
listed_product, created = ProducerProduct.objects.get_or_create(
product=product, producer=member)
#elif role == "consumer":
#todo: shd these be auto-created at all?
# and if so, what MemberProductList?
# listed_product, created = CustomerProduct.objects.get_or_create(
# product=product, customer=member)
else:
if plan:
if plan.from_date >= from_dt and plan.to_date <= to_dt:
#pass
plan.delete()
else:
#import pdb; pdb.set_trace()
if plan.to_date > to_dt:
early_from_dt = plan.from_date
if plan.from_date < from_dt:
early_to_dt = from_dt - datetime.timedelta(days=1)
earlier_plan = ProductPlan(
member=plan.member,
product=plan.product,
quantity=plan.quantity,
from_date=early_from_dt,
to_date=early_to_dt,
role=plan.role,
inventoried=plan.inventoried,
distributor=plan.distributor,
)
earlier_plan.save()
plan.from_date = to_dt + datetime.timedelta(days=1)
plan.save()
else:
plan.to_date= from_dt - datetime.timedelta(days=1)
plan.save()
from_date = from_date.strftime('%Y_%m_%d')
to_date = to_date.strftime('%Y_%m_%d')
return HttpResponseRedirect('/%s/%s/%s/%s/'
% ('customer/customerplans', from_date, to_date, member_id))
return render_to_response('distribution/planning_table.html',
{
'from_date': from_date,
'to_date': to_date,
'plan_table': plan_table,
'forms': forms,
'plan_type': plan_type,
'member': member,
'list_type': list_type,
'tabnav': "customer/customer_tabnav.html",
}, context_instance=RequestContext(request))
0
Example 38
Project: virtmgr Source File: views.py
def snapshot(request, host_id, vname):
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
kvm_host = Host.objects.get(user=request.user.id, id=host_id)
def add_error(msg, type_err):
error_msg = Log(host_id=host_id,
type=type_err,
message=msg,
user_id=request.user.id
)
error_msg.save()
def get_vms():
try:
vname = {}
for id in conn.listDomainsID():
id = int(id)
dom = conn.lookupByID(id)
vname[dom.name()] = dom.info()[0]
for id in conn.listDefinedDomains():
dom = conn.lookupByName(id)
vname[dom.name()] = dom.info()[0]
return vname
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def get_vm_snapshots():
try:
vname = {}
for id in conn.listDomainsID():
id = int(id)
dom = conn.lookupByID(id)
if dom.snapshotNum(0) != 0:
vname[dom.name()] = dom.info()[0]
for id in conn.listDefinedDomains():
dom = conn.lookupByName(id)
if dom.snapshotNum(0) != 0:
vname[dom.name()] = dom.info()[0]
return vname
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def vm_conn():
try:
flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE]
auth = [flags, creds, None]
uri = 'qemu+tcp://' + kvm_host.ipaddr + '/system'
conn = libvirt.openAuth(uri, auth, 0)
return conn
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
if not kvm_host.login or not kvm_host.passwd:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = request.session['login_kvm']
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = request.session['passwd_kvm']
else:
return -1
return 0
else:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = kvm_host.login
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = kvm_host.passwd
else:
return -1
return 0
def get_dom(vname):
try:
dom = conn.lookupByName(vname)
return dom
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def get_snapshots():
try:
snapshots = {}
all_snapshot = dom.snapshotListNames(0)
for snapshot in all_snapshot:
snapshots[snapshot] = (datetime.fromtimestamp(int(snapshot)), dom.info()[0])
return snapshots
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def del_snapshot(name_snap):
try:
snap = dom.snapshotLookupByName(name_snap,0)
snap.delete(0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
def revert_snapshot(name_snap):
try:
snap = dom.snapshotLookupByName(name_snap,0)
dom.revertToSnapshot(snap,0)
except libvirt.libvirtError as e:
add_error(e,'libvirt')
return "error"
conn = vm_conn()
all_vm_snapshots = get_vm_snapshots()
dom = get_dom(vname)
vm_snapshot = get_snapshots()
all_vm = get_vms()
if not vm_snapshot:
return HttpResponseRedirect('/snapshot/%s/' % (host_id))
if request.method == 'POST':
if request.POST.get('delete',''):
name = request.POST.get('name','')
msg = _('Delete snapshot VM: ')
msg = msg + vname + ' => ' + name
add_error(msg,'user')
del_snapshot(name)
return HttpResponseRedirect('/snapshot/%s/%s/' % (host_id, vname))
if request.POST.get('revert',''):
name = request.POST.get('name','')
msg = _('Revert snapshot VM: ')
msg = msg + vname + ' => ' + name
add_error(msg,'user')
revert_snapshot(name)
message = _('Successful revert snapshot: ')
message = message + name
conn.close()
return render_to_response('snapshot.html', locals())
0
Example 39
Project: foodnetwork Source File: views.py
@login_required
def planning_table(request, member_id, list_type, from_date, to_date):
try:
member = Party.objects.get(pk=member_id)
except Party.DoesNotExist:
raise Http404
role = "producer"
plan_type = "Production"
if member.is_customer():
role = "consumer"
plan_type = "Consumption"
try:
from_date = datetime.datetime(*time.strptime(from_date, '%Y_%m_%d')[0:5]).date()
to_date = datetime.datetime(*time.strptime(to_date, '%Y_%m_%d')[0:5]).date()
except ValueError:
raise Http404
# force from_date to Monday, to_date to Sunday
from_date = from_date - datetime.timedelta(days=datetime.date.weekday(from_date))
to_date = to_date - datetime.timedelta(days=datetime.date.weekday(to_date)+1)
to_date = to_date + datetime.timedelta(days=7)
products = None
if list_type == "M":
if role == "consumer":
products = CustomerProduct.objects.filter(customer=member, planned=True)
else:
products = ProducerProduct.objects.filter(producer=member, planned=True)
if not products:
products = Product.objects.filter(plannable=True)
list_type = "A"
plan_table = plan_weeks(member, products, from_date, to_date)
forms = create_weekly_plan_forms(plan_table.rows, data=request.POST or None)
if request.method == "POST":
for row in forms:
if row.formset.is_valid():
for form in row.formset.forms:
data = form.cleaned_data
qty = data['quantity']
plan_id = data['plan_id']
from_dt = data['from_date']
to_dt = data['to_date']
product_id = data['product_id']
plan = None
if plan_id:
# what if plan was changed by prev cell?
plan = ProductPlan.objects.get(id=plan_id)
if plan.to_date < from_dt or plan.from_date > to_dt:
plan = None
if qty:
if plan:
if not qty == plan.quantity:
if plan.from_date >= from_dt and plan.to_date <= to_dt:
plan.quantity = qty
plan.save()
else:
if plan.from_date < from_dt:
new_to_dt = from_dt - datetime.timedelta(days=1)
earlier_plan = ProductPlan(
member=plan.member,
product=plan.product,
quantity=plan.quantity,
from_date=plan.from_date,
to_date=new_to_dt,
role=plan.role,
inventoried=plan.inventoried,
distributor=plan.distributor,
)
earlier_plan.save()
if plan.to_date > to_dt:
new_plan = ProductPlan(
member=plan.member,
product=plan.product,
quantity=qty,
from_date=from_dt,
to_date=to_dt,
role=plan.role,
inventoried=plan.inventoried,
distributor=plan.distributor,
)
new_plan.save()
plan.from_date = to_dt + datetime.timedelta(days=1)
plan.save()
else:
plan.from_date=from_dt
plan.quantity=qty
plan.save()
else:
product = Product.objects.get(id=product_id)
new_plan = ProductPlan(
member=member,
product=product,
quantity=qty,
from_date=from_dt,
to_date=to_dt,
role=role,
)
new_plan.save()
if role == "producer":
listed_product, created = ProducerProduct.objects.get_or_create(
product=product, producer=member)
#elif role == "consumer":
# listed_product, created = CustomerProduct.objects.get_or_create(
# product=product, customer=member)
else:
if plan:
if plan.from_date >= from_dt and plan.to_date <= to_dt:
plan.delete()
else:
if plan.to_date > to_dt:
early_from_dt = plan.from_date
if plan.from_date < from_dt:
early_to_dt = from_dt - datetime.timedelta(days=1)
earlier_plan = ProductPlan(
member=plan.member,
product=plan.product,
quantity=plan.quantity,
from_date=early_from_dt,
to_date=early_to_dt,
role=plan.role,
inventoried=plan.inventoried,
distributor=plan.distributor,
)
earlier_plan.save()
plan.from_date = to_dt + datetime.timedelta(days=1)
plan.save()
else:
plan.to_date= from_dt - datetime.timedelta(days=1)
plan.save()
from_date = from_date.strftime('%Y_%m_%d')
to_date = to_date.strftime('%Y_%m_%d')
return HttpResponseRedirect('/%s/%s/%s/%s/'
% ('producer/producerplans', from_date, to_date, member_id))
return render_to_response('distribution/planning_table.html',
{
'from_date': from_date,
'to_date': to_date,
'plan_table': plan_table,
'forms': forms,
'plan_type': plan_type,
'member': member,
'list_type': list_type,
'tabnav': "producer/producer_tabnav.html",
}, context_instance=RequestContext(request))
0
Example 40
Project: django-adminactions Source File: mass_update.py
def mass_update(modeladmin, request, queryset): # noqa
"""
mass update queryset
"""
def not_required(field, **kwargs):
""" force all fields as not required"""
kwargs['required'] = False
return field.formfield(**kwargs)
def _doit():
errors = {}
updated = 0
for record in queryset:
for field_name, value_or_func in list(form.cleaned_data.items()):
if callable(value_or_func):
old_value = getattr(record, field_name)
setattr(record, field_name, value_or_func(old_value))
else:
setattr(record, field_name, value_or_func)
if clean:
record.clean()
record.save()
updated += 1
if updated:
messages.info(request, _("Updated %s records") % updated)
if len(errors):
messages.error(request, "%s records not updated due errors" % len(errors))
adminaction_end.send(sender=modeladmin.model,
action='mass_update',
request=request,
queryset=queryset,
modeladmin=modeladmin,
form=form,
errors=errors,
updated=updated)
opts = modeladmin.model._meta
perm = "{0}.{1}".format(opts.app_label, get_permission_codename('adminactions_massupdate', opts))
if not request.user.has_perm(perm):
messages.error(request, _('Sorry you do not have rights to execute this action'))
return
try:
adminaction_requested.send(sender=modeladmin.model,
action='mass_update',
request=request,
queryset=queryset,
modeladmin=modeladmin)
except ActionInterrupted as e:
messages.error(request, str(e))
return
# Allows to specified a custom mass update Form in the ModelAdmin
mass_update_form = getattr(modeladmin, 'mass_update_form', MassUpdateForm)
MForm = modelform_factory(modeladmin.model, form=mass_update_form,
exclude=('pk',),
formfield_callback=not_required)
grouped = defaultdict(lambda: [])
selected_fields = []
initial = {'_selected_action': request.POST.getlist(helpers.ACTION_CHECKBOX_NAME),
'select_across': request.POST.get('select_across') == '1',
'action': 'mass_update'}
if 'apply' in request.POST:
form = MForm(request.POST)
if form.is_valid():
try:
adminaction_start.send(sender=modeladmin.model,
action='mass_update',
request=request,
queryset=queryset,
modeladmin=modeladmin,
form=form)
except ActionInterrupted as e:
messages.error(request, str(e))
return HttpResponseRedirect(request.get_full_path())
# need_transaction = form.cleaned_data.get('_unique_transaction', False)
validate = form.cleaned_data.get('_validate', False)
clean = form.cleaned_data.get('_clean', False)
if validate:
with compat.atomic():
_doit()
else:
values = {}
for field_name, value in list(form.cleaned_data.items()):
if isinstance(form.fields[field_name], ModelMultipleChoiceField):
messages.error(request, "Unable no mass update ManyToManyField without 'validate'")
return HttpResponseRedirect(request.get_full_path())
elif callable(value):
messages.error(request, "Unable no mass update using operators without 'validate'")
return HttpResponseRedirect(request.get_full_path())
elif field_name not in ['_selected_action', '_validate', 'select_across', 'action',
'_unique_transaction', '_clean']:
values[field_name] = value
queryset.update(**values)
return HttpResponseRedirect(request.get_full_path())
else:
initial.update({'action': 'mass_update', '_validate': 1})
# form = MForm(initial=initial)
prefill_with = request.POST.get('prefill-with', None)
prefill_instance = None
try:
# Gets the instance directly from the queryset for data security
prefill_instance = queryset.get(pk=prefill_with)
except ObjectDoesNotExist:
pass
form = MForm(initial=initial, instance=prefill_instance)
for el in queryset.all()[:10]:
for f in modeladmin.model._meta.fields:
if f.name not in form._no_sample_for:
if hasattr(f, 'flatchoices') and f.flatchoices:
grouped[f.name] = list(dict(getattr(f, 'flatchoices')).values())
elif hasattr(f, 'choices') and f.choices:
grouped[f.name] = list(dict(getattr(f, 'choices')).values())
elif isinstance(f, df.BooleanField):
grouped[f.name] = [True, False]
else:
value = getattr(el, f.name)
if value is not None and value not in grouped[f.name]:
grouped[f.name].append(value)
initial[f.name] = initial.get(f.name, value)
adminForm = helpers.AdminForm(form, modeladmin.get_fieldsets(request), {}, [], model_admin=modeladmin)
media = modeladmin.media + adminForm.media
dthandler = lambda obj: obj.isoformat() if isinstance(obj, datetime.date) else str(obj)
tpl = 'adminactions/mass_update.html'
ctx = {'adminform': adminForm,
'form': form,
'action_short_description': mass_update.short_description,
'title': u"%s (%s)" % (
mass_update.short_description.capitalize(),
smart_text(modeladmin.opts.verbose_name_plural),
),
'grouped': grouped,
'fieldvalues': json.dumps(grouped, default=dthandler),
'change': True,
'selected_fields': selected_fields,
'is_popup': False,
'save_as': False,
'has_delete_permission': False,
'has_add_permission': False,
'has_change_permission': True,
'opts': modeladmin.model._meta,
'app_label': modeladmin.model._meta.app_label,
# 'action': 'mass_update',
# 'select_across': request.POST.get('select_across')=='1',
'media': mark_safe(media),
'selection': queryset}
if django.VERSION[:2] > (1, 7):
ctx.update(modeladmin.admin_site.each_context(request))
else:
ctx.update(modeladmin.admin_site.each_context())
if django.VERSION[:2] > (1, 8):
return render(request, tpl, context=ctx)
else:
return render_to_response(tpl, RequestContext(request, ctx))
0
Example 41
Project: zorna Source File: views.py
@login_required()
def edit_story(request, story):
allowed_objects = get_allowed_objects(
request.user, ArticleCategory, 'manager')
try:
story = ArticleStory.objects.select_related().get(pk=story)
categories = story.categories.all()
intersect = set(allowed_objects).intersection( set([category.pk for category in categories]))
if story.owner != request.user and not intersect:
return HttpResponseRedirect('/')
except Exception as e:
print e
return HttpResponseRedirect('/')
attachments = story.articleattachments_set.all()
if request.method == 'POST':
if 'bdelstory' in request.POST:
story.articleattachments_set.all().delete()
pk = story.pk
story.delete()
try:
shutil.rmtree(u"%s/%s" % (get_upload_articles_images(), pk))
except:
pass
try:
shutil.rmtree(u"%s/%s" % (get_upload_articles_files(), pk))
except:
pass
return HttpResponseRedirect(reverse('writer_stories_list', args=[]))
form_story = ArticleStoryForm(
request.POST, request.FILES, instance=story, request=request)
if form_story.is_valid():
if 'selected_image' in request.POST:
story.image.delete()
try:
shutil.rmtree(u"%s/%s" % (get_upload_articles_images(), story.pk))
except:
pass
if 'image' in request.FILES:
story.mimetype = request.FILES['image'].content_type
else:
image_file = None
story.modifier = request.user
story.save()
story.categories.clear()
selected_categories = request.POST.getlist('_selected_action')
story.categories = selected_categories
form_story = ArticleStoryForm(instance=story, request=request)
if len(attachments) < 2:
fa_set = formset_factory(
ArticleAttachmentsForm, extra=2 - len(attachments))
form_attachments_set = fa_set(request.POST, request.FILES)
if form_attachments_set.is_valid():
for i in range(0, form_attachments_set.total_form_count()):
form = form_attachments_set.forms[i]
try:
file = request.FILES['form-' + str(
i) + '-attached_file']
attachment = ArticleAttachments(description=form.cleaned_data[
'description'], mimetype=file.content_type)
attachment.article = story
attachment.save()
attachment.attached_file.save(file.name, file)
except:
pass
if 'selected_attachments' in request.POST:
att = request.POST.getlist('selected_attachments')
ArticleAttachments.objects.filter(pk__in=att).delete()
attachments = story.articleattachments_set.all()
extra = len(attachments)
if extra < 2:
fa_set = formset_factory(ArticleAttachmentsForm, extra=2 - extra)
form_attachments_set = fa_set()
else:
form_attachments_set = None
tags = map(int, request.POST.getlist('article_tags[]'))
story.tags.clear()
tags = ArticleTags.objects.filter(pk__in=tags)
story.tags.add(*tags)
if story.categories:
notify_users(request, story, story.categories.all(), False)
else:
form_story = ArticleStoryForm(instance=story, request=request)
extra = len(attachments)
if extra < 2:
fa_set = formset_factory(ArticleAttachmentsForm, extra=2 - extra)
form_attachments_set = fa_set()
else:
form_attachments_set = None
tags = ArticleTags.objects.all()
story_tags = story.tags.all()
for tag in tags:
if tag in story_tags:
tag.checked = True
context = RequestContext(request)
extra_context = {'form_story': form_story,
'story': story,
'tags': tags,
'form_attachments': form_attachments_set,
'attachments': attachments,
'categories': [c.pk for c in categories],
}
return render_to_response('articles/edit_article.html', extra_context, context_instance=context)
0
Example 42
Project: PyClassLessons Source File: comments.py
@csrf_protect
@require_POST
def post_comment(request, next=None, using=None):
"""
Post a comment.
HTTP POST is required. If ``POST['submit'] == "preview"`` or if there are
errors a preview template, ``comments/preview.html``, will be rendered.
"""
# Fill out some initial data fields from an authenticated user, if present
data = request.POST.copy()
if request.user.is_authenticated():
if not data.get('name', ''):
data["name"] = request.user.get_full_name() or request.user.get_username()
if not data.get('email', ''):
data["email"] = request.user.email
# Look up the object we're trying to comment about
ctype = data.get("content_type")
object_pk = data.get("object_pk")
if ctype is None or object_pk is None:
return CommentPostBadRequest("Missing content_type or object_pk field.")
try:
model = apps.get_model(ctype)
target = model._default_manager.using(using).get(pk=object_pk)
except TypeError:
return CommentPostBadRequest(
"Invalid content_type value: %r" % escape(ctype))
except LookupError:
return CommentPostBadRequest(
"The given content-type %r does not resolve to a valid model." % \
escape(ctype))
except ObjectDoesNotExist:
return CommentPostBadRequest(
"No object matching content-type %r and object PK %r exists." % \
(escape(ctype), escape(object_pk)))
except (ValueError, ValidationError) as e:
return CommentPostBadRequest(
"Attempting go get content-type %r and object PK %r exists raised %s" % \
(escape(ctype), escape(object_pk), e.__class__.__name__))
# Do we want to preview the comment?
preview = "preview" in data
# Construct the comment form
form = comments.get_form()(target, data=data)
# Check security information
if form.security_errors():
return CommentPostBadRequest(
"The comment form failed security verification: %s" % \
escape(str(form.security_errors())))
# If there are errors or if we requested a preview show the comment
if form.errors or preview:
template_list = [
# These first two exist for purely historical reasons.
# Django v1.0 and v1.1 allowed the underscore format for
# preview templates, so we have to preserve that format.
"comments/%s_%s_preview.html" % (model._meta.app_label, model._meta.model_name),
"comments/%s_preview.html" % model._meta.app_label,
# Now the usual directory based template hierarchy.
"comments/%s/%s/preview.html" % (model._meta.app_label, model._meta.model_name),
"comments/%s/preview.html" % model._meta.app_label,
"comments/preview.html",
]
return render_to_response(
template_list, {
"comment": form.data.get("comment", ""),
"form": form,
"next": data.get("next", next),
},
RequestContext(request, {})
)
# Otherwise create the comment
comment = form.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender=comment.__class__,
comment=comment,
request=request
)
for (receiver, response) in responses:
if response == False:
return CommentPostBadRequest(
"comment_will_be_posted receiver %r killed the comment" % receiver.__name__)
# Save the comment and signal that it was saved
comment.save()
signals.comment_was_posted.send(
sender=comment.__class__,
comment=comment,
request=request
)
return next_redirect(request, fallback=next or 'comments-comment-done',
c=comment._get_pk_val())
0
Example 43
Project: zorna Source File: views.py
def edit_page(request):
b_pages_manager, b_templates_manager = get_pages_access(request.user)
if b_pages_manager:
from zorna.utils import get_context_text
page = request.REQUEST.get('file', '')
path_tf = os.path.join(
settings.PROJECT_PATH, settings.ZORNA_CONTENT, page)
header, text = get_context_text(path_tf)
blocks = get_blocks(request, text)
import yaml
context_yaml = yaml.load(header)
if request.method == 'POST':
docuement = ''
try:
import codecs
lflr = '\r\n'
fd = codecs.open(path_tf, "r+", "utf-8")
text = fd.read()
to_add = []
for key, value in request.POST.iteritems():
if key[0:2] == '__':
docuement = docuement + ' ' + value
repl = "%s block %s %s\n%s\n%s endblock %s" % (
'{%', key, '%}', value, '{%', '%}')
pre = re.compile(r'(%s\s*block\s*%s\s*%s)(.*?)(%s\s*endblock.*?\s*%s)' % (re.escape(
'{%'), key, re.escape('%}'), re.escape('{%'), re.escape('%}')), re.M | re.DOTALL)
if pre.search(text):
text = pre.sub(repl, text)
else:
to_add.append(repl + lflr)
description = request.POST.get(
"description", '').replace('\n', '')
tab_ctx = {'title': request.POST.get("title", ''), 'description': description, 'keywords': request.POST.get(
"keywords", ''), 'created': str(datetime.datetime.now()), 'author': str(request.user.pk)}
if not header:
context_yaml = tab_ctx
else:
context_yaml.update(tab_ctx)
result = ''
for k, v in context_yaml.iteritems():
if k in request.POST:
v = request.POST.get(k, '').replace('\n', '')
result = result + k + ": '%s'%s" % (
v.replace("'", "''"), lflr)
ctx = "%s zorna %s%s%s%s" % ('{%', lflr, result, lflr, '%}')
pre = re.compile(r'(%s\s*zorna)(.*?)(\s*%s)' % (
re.escape('{%'), re.escape('%}')), re.M | re.DOTALL)
if pre.search(text):
text = pre.sub(ctx, text)
else:
text = text + lflr + ctx
what = request.REQUEST.get('what', 'save')
if what == 'save':
fd.seek(0)
fd.truncate()
fd.write(text)
fd.close()
zorna_page_save.send(
None, created=False, content=docuement, title=request.POST.get("title", page), url=page)
else:
# create temporary file
head, tail = os.path.split(page)
if head:
head = head + '/'
temp_page = head + 'temp-%s' % tail
path_tempf = os.path.join(
settings.PROJECT_PATH, settings.ZORNA_CONTENT, temp_page)
fd = open(path_tempf, 'w+')
fd.write(text.encode('UTF-8'))
fd.close()
return HttpResponseRedirect(reverse('preview_page', args=[os.path.splitext(temp_page)[0]]))
except Exception as e:
ret = {'status': 'error', 'message': 'Error: %s' % str(e)}
return HttpResponse(simplejson.dumps(ret))
ret = {'status': 'success', 'message':
'Your changes have been saved successfully.'}
return HttpResponse(simplejson.dumps(ret))
form = PageEditFileForm(extra=blocks, request=request)
if header:
initial_data = {}
initial_data['title'] = context_yaml[
'title'] if 'title' in context_yaml else ''
initial_data['description'] = context_yaml[
'description'] if 'description' in context_yaml else ''
initial_data['keywords'] = context_yaml[
'keywords'] if 'keywords' in context_yaml else ''
for e in ['author', 'created', 'title', 'keywords', 'description']:
if e in context_yaml:
del context_yaml[e]
form_context = PageEditFileContextForm(
initial=initial_data, extra=context_yaml)
else:
form_context = None
extra_context = {'form_context': form_context, 'form':
form, 'cdir_components': format_components(page), 'template_file': page}
context = RequestContext(request)
return render_to_response('pages/fm_edit_file.html', extra_context, context_instance=context)
else:
return HttpResponse('')
0
Example 44
@csrf_exempt
@never_cache
@staff_member_required
def log(request, template_name=TEMPLATE_NAME, \
template_name_ajax=TEMPLATE_NAME_AJAX):
"""
Get number of log entires. Serves both non-AJAX and AJAX driven requests.
Since we have a breakdown of entries per day per entry and we have an AJAX
driven infinite scroll and we want to avoid having duplicated date headers,
we always pass a variable named "last_date" when making another request
to our main AJAX-driven view. So... this is our case scenario:
Initial timeline rendered as a normal HTML (non AJAX request) (from a list
of log entries). We send date of last element as "last_date" to the context
too, which will be used an an initial value for a global JavaScript
variable. Later on that date will be used to send it to the AJAX driven
view and used in rendering ("render_to_string" method). After we have
rendered the HTML to send back, we get the last date of the last element
and send it along with the HTML rendered to our view in JSON response.
When receiving the JSON response, we update the above mentioned global
JavaScript variable with the value given.
:param request: django.http.HttpRequest
:param template_name: str
:param template_name_ajax: str
:return: django.http.HttpResponse
This view accepts the following POST variables (all optional).
:param page: int - Page number to get.
:param user_id: int - If set, used to filter the user by.
:param last_date: str - Example value "2012-05-24".
:param start_date: str - If set, used as a start date to filter the actions
with. Example value "2012-05-24".
:param end_date: str - If set, used as an end date to filter the actions
with. Example value "2012-05-24".
NOTE: If it gets too complicatd with filtering, we need to have forms to
validate and process the POST data.
"""
def _get_date_from_string(s):
"""
Gets date from a string given.
:param s: str - date in string format
:return: datetime.datetime
"""
try:
return datetime.date(*map(lambda x: int(x), s.split("-")))
except Exception as e:
return ""
try:
page = int(request.POST.get('page', 1))
if page < 1:
page = 1
except Exception as e:
page = 1
users = []
content_types = []
filter_form = None
if 'POST' == request.method:
post = dict(request.POST)
if 'users[]' in post:
post['users'] = post.pop('users[]')
if 'content_types[]' in post:
post['content_types'] = post.pop('content_types[]')
filter_form = FilterForm(post)
if filter_form.is_valid():
users = filter_form.cleaned_data['users']
content_types = filter_form.cleaned_data['content_types']
else:
pass # Anything to do here?
else:
filter_form = FilterForm()
# Some kind of a pagination
start = (page - 1) * NUMBER_OF_ENTRIES_PER_PAGE
end = page * NUMBER_OF_ENTRIES_PER_PAGE
# Getting admin log entires taking page number into consideration.
log_entries = LogEntry.objects.all().select_related('content_type', 'user')
start_date = _get_date_from_string(request.POST.get('start_date'))
end_date = _get_date_from_string(request.POST.get('end_date'))
if start_date:
log_entries = log_entries.filter(action_time__gte=start_date) # TODO
if end_date:
log_entries = log_entries.filter(action_time__lte=end_date) # TODO
# If users given, filtering by users
if users:
log_entries = log_entries.filter(user__id__in=users)
# If content types given, filtering by content types
if content_types:
log_entries = log_entries.filter(content_type__id__in=content_types)
# Applying limits / freezing the queryset
log_entries = log_entries[start:end]
if log_entries:
last_date = date_format(
log_entries[len(log_entries) - 1].action_time, "Y-m-d"
)
else:
last_date = request.POST.get('last_date', None)
# Using different template for AJAX driven requests
if request.is_ajax():
# Context to render the AJAX driven HTML with
context = {
'admin_log': log_entries,
'number_of_entries_per_page': NUMBER_OF_ENTRIES_PER_PAGE,
'page': page,
'last_date': request.POST.get('last_date', None),
'SINGLE_LOG_ENTRY_DATE_FORMAT': SINGLE_LOG_ENTRY_DATE_FORMAT,
'LOG_ENTRIES_DAY_HEADINGS_DATE_FORMAT': \
LOG_ENTRIES_DAY_HEADINGS_DATE_FORMAT
}
# Rendering HTML for an AJAX driven request
html = render_to_string(
template_name_ajax,
context,
context_instance=RequestContext(request)
)
# Context to send back to user in a JSON response
context = {
'html': html,
'last_date': last_date,
'success': 1 if len(log_entries) else 0
}
return HttpResponse(json.dumps(context))
# Context for a non-AJAX request
context = {
'admin_log': log_entries,
'number_of_entries_per_page': NUMBER_OF_ENTRIES_PER_PAGE,
'page': page,
'last_date': last_date,
'start_date': date_format(start_date, "Y-m-d") if start_date else "",
'end_date': date_format(end_date, "Y-m-d") if end_date else "",
'users': [int(u) for u in users],
'content_types': [int(ct) for ct in content_types],
'filter_form': filter_form,
'SINGLE_LOG_ENTRY_DATE_FORMAT': SINGLE_LOG_ENTRY_DATE_FORMAT,
'LOG_ENTRIES_DAY_HEADINGS_DATE_FORMAT': \
LOG_ENTRIES_DAY_HEADINGS_DATE_FORMAT,
'title': _("Timeline") # For template breadcrumbs, etc.
}
return render_to_response(
template_name, context, context_instance=RequestContext(request)
)
0
Example 45
Project: virtmgr Source File: views.py
def index(request, host_id, vname):
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
kvm_host = Host.objects.get(user=request.user.id, id=host_id)
def add_error(msg, type_err):
error_msg = Log(host_id=host_id,
type=type_err,
message=msg,
user_id=request.user.id
)
error_msg.save()
def get_vms():
try:
vname = {}
for id in conn.listDomainsID():
id = int(id)
dom = conn.lookupByID(id)
vname[dom.name()] = dom.info()[0]
for id in conn.listDefinedDomains():
dom = conn.lookupByName(id)
vname[dom.name()] = dom.info()[0]
return vname
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_storages():
try:
storages = []
for name in conn.listStoragePools():
storages.append(name)
for name in conn.listDefinedStoragePools():
storages.append(name)
return storages
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def vm_conn():
try:
flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE]
auth = [flags, creds, None]
uri = 'qemu+tcp://' + kvm_host.ipaddr + '/system'
conn = libvirt.openAuth(uri, auth, 0)
return conn
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_dom(vname):
try:
dom = conn.lookupByName(vname)
return dom
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
if not kvm_host.login or not kvm_host.passwd:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = request.session['login_kvm']
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = request.session['passwd_kvm']
else:
return -1
return 0
else:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = kvm_host.login
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = kvm_host.passwd
else:
return -1
return 0
def get_vm_active():
try:
state = dom.isActive()
return state
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_uuid():
try:
xml = dom.XMLDesc(0)
uuid = util.get_xml_path(xml, "/domain/uuid")
return uuid
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_xml():
try:
xml = dom.XMLDesc(0)
xml_spl = xml.split('\n')
return xml_spl
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_mem():
try:
xml = dom.XMLDesc(0)
mem = util.get_xml_path(xml, "/domain/currentMemory")
mem = int(mem) * 1024
return mem
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_core():
try:
xml = dom.XMLDesc(0)
cpu = util.get_xml_path(xml, "/domain/vcpu")
return cpu
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_vnc():
try:
xml = dom.XMLDesc(0)
vnc = util.get_xml_path(xml, "/domain/devices/graphics/@port")
return vnc
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_hdd():
try:
xml = dom.XMLDesc(0)
hdd_path = util.get_xml_path(xml, "/domain/devices/disk[1]/source/@file")
hdd_fmt = util.get_xml_path(xml, "/domain/devices/disk[1]/driver/@type")
#image = re.sub('\/.*\/', '', hdd_path)
size = dom.blockInfo(hdd_path, 0)[0]
#return image, size, hdd_fmt
return hdd_path, size, hdd_fmt
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_cdrom():
try:
xml = dom.XMLDesc(0)
cdr_path = util.get_xml_path(xml, "/domain/devices/disk[2]/source/@file")
if cdr_path:
#image = re.sub('\/.*\/', '', cdr_path)
size = dom.blockInfo(cdr_path, 0)[0]
#return image, cdr_path, size
return cdr_path, cdr_path, size
else:
return cdr_path
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_boot_menu():
try:
xml = dom.XMLDesc(0)
boot_menu = util.get_xml_path(xml, "/domain/os/bootmenu/@enable")
return boot_menu
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_arch():
try:
xml = dom.XMLDesc(0)
arch = util.get_xml_path(xml, "/domain/os/type/@arch")
return arch
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_nic():
try:
xml = dom.XMLDesc(0)
mac = util.get_xml_path(xml, "/domain/devices/interface/mac/@address")
nic = util.get_xml_path(xml, "/domain/devices/interface/source/@network")
if nic is None:
nic = util.get_xml_path(xml, "/domain/devices/interface/source/@bridge")
return mac, nic
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def mnt_iso_on(vol):
try:
for storage in storages:
stg = conn.storagePoolLookupByName(storage)
for img in stg.listVolumes():
if vol == img:
vl = stg.storageVolLookupByName(vol)
xml = """<disk type='file' device='cdrom'>
<driver name='qemu' type='raw'/>
<target dev='hdc' bus='ide'/>
<source file='%s'/>
<readonly/>
</disk>""" % vl.path()
dom.attachDevice(xml)
xmldom = dom.XMLDesc(0)
conn.defineXML(xmldom)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def mnt_iso_off(vol):
try:
for storage in storages:
stg = conn.storagePoolLookupByName(storage)
for img in stg.listVolumes():
if vol == img:
vl = stg.storageVolLookupByName(vol)
xml = dom.XMLDesc(0)
iso = "<disk type='file' device='cdrom'>\n <driver name='qemu' type='raw'/>\n <source file='%s'/>" % vl.path()
xmldom = xml.replace("<disk type='file' device='cdrom'>\n <driver name='qemu' type='raw'/>", iso)
conn.defineXML(xmldom)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def umnt_iso_on():
try:
xml = """<disk type='file' device='cdrom'>
<driver name="qemu" type='raw'/>
<target dev='hdc' bus='ide'/>
<readonly/>
</disk>"""
dom.attachDevice(xml)
xmldom = dom.XMLDesc(0)
conn.defineXML(xmldom)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def umnt_iso_off():
try:
xml = dom.XMLDesc(0)
cdrom = get_vm_cdrom()[1]
xmldom = xml.replace("<source file='%s'/>\n" % cdrom,"")
conn.defineXML(xmldom)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def find_all_iso():
try:
iso = []
for storage in storages:
stg = conn.storagePoolLookupByName(storage)
stg.refresh(0)
for img in stg.listVolumes():
if re.findall(".iso", img) or re.findall(".ISO", img):
iso.append(img)
return iso
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_autostart():
try:
return dom.autostart()
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def page_refresh():
try:
return HttpResponseRedirect('/vm/' + host_id + '/' + vname + '/' )
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_vm_state():
try:
return dom.info()[0]
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def vm_cpu_usage():
try:
nbcore = conn.getInfo()[2]
cpu_use_ago = dom.info()[4]
time.sleep(1)
cpu_use_now = dom.info()[4]
diff_usage = cpu_use_now - cpu_use_ago
cpu_usage = 100 * diff_usage / (1 * nbcore * 10**9L)
return cpu_usage
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_memusage():
try:
allmem = conn.getInfo()[1] * 1048576
dom_mem = dom.info()[1] * 1024
percent = (dom_mem * 100) / allmem
return allmem, percent
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_all_core():
try:
allcore = conn.getInfo()[2]
return allcore
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def vm_create_snapshot():
try:
xml = """<domainsnapshot>\n
<name>%d</name>\n
<state>shutoff</state>\n
<creationTime>%d</creationTime>\n""" % (time.time(), time.time())
xml += dom.XMLDesc(0)
xml += """<active>0</active>\n
</domainsnapshot>"""
dom.snapshotCreateXML(xml, 0)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_snapshot_num():
try:
return dom.snapshotNum(0)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
conn = vm_conn()
errors = []
if conn == None:
return HttpResponseRedirect('/overview/' + host + '/')
all_vm = get_vms()
dom = get_dom(vname)
active = get_vm_active()
state = get_vm_state()
uuid = get_vm_uuid()
memory = get_vm_mem()
core = get_vm_core()
autostart = get_vm_autostart()
vnc_port = get_vm_vnc()
hdd = get_vm_hdd()
boot_menu = get_vm_boot_menu()
vm_arch = get_vm_arch()
vm_nic = get_vm_nic()
cdrom = get_vm_cdrom()
storages = get_storages()
isos = find_all_iso()
all_core = get_all_core()
cpu_usage = vm_cpu_usage()
mem_usage = get_memusage()
num_snapshot = get_snapshot_num()
vm_xml = get_vm_xml()
# Post form html
if request.method == 'POST':
if request.POST.get('suspend',''):
try:
dom.suspend()
msg = _('Suspend VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy suspended')
errors.append(msg)
if request.POST.get('resume',''):
try:
dom.resume()
msg = _('Resume VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy resume')
errors.append(msg)
if request.POST.get('start',''):
try:
dom.create()
msg = _('Start VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy start')
errors.append(msg)
if request.POST.get('shutdown',''):
try:
dom.shutdown()
msg = _('Shutdown VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy shutdown')
errors.append(msg)
if request.POST.get('destroy',''):
try:
dom.destroy()
msg = _('Force shutdown VM: ')
msg = msg + vname
add_error(msg, 'user')
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: VM alredy shutdown')
errors.append(msg)
if request.POST.get('snapshot',''):
try:
msg = _('Create snapshot for VM: ')
msg = msg + vname
add_error(msg, 'user')
vm_create_snapshot()
message = _('Successful create snapshot')
return render_to_response('vm.html', locals())
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
msg = _('Error: create snapshot')
errors.append(msg)
if request.POST.get('auto_on',''):
try:
msg = _('Enable autostart for VM: ')
msg = msg + vname
add_error(msg, 'user')
dom.setAutostart(1)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
if request.POST.get('auto_off',''):
try:
msg = _('Disable autostart for VM: ')
msg = msg + vname
add_error(msg, 'user')
dom.setAutostart(0)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
if request.POST.get('disconnect',''):
iso = request.POST.get('iso_img','')
if state == 1:
umnt_iso_on()
else:
umnt_iso_off()
if request.POST.get('connect',''):
iso = request.POST.get('iso_img','')
if state == 1:
mnt_iso_on(iso)
else:
mnt_iso_off(iso)
if request.POST.get('undefine',''):
try:
dom.undefine()
msg = _('Undefine VM: ')
msg = msg + vname
add_error(msg, 'user')
return HttpResponseRedirect('/overview/%s/' % (host_id))
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
if not errors:
return HttpResponseRedirect('/vm/%s/%s/' % (host_id, vname))
else:
return render_to_response('vm.html', locals())
conn.close()
return render_to_response('vm.html', locals())
0
Example 46
Project: talk.org Source File: comments.py
def post_comment(request, extra_context=None, context_processors=None):
"""
Post a comment
Redirects to the `comments.comments.comment_was_posted` view upon success.
Templates: `comment_preview`
Context:
comment
the comment being posted
comment_form
the comment form
options
comment options
target
comment target
hash
security hash (must be included in a posted form to succesfully
post a comment).
rating_options
comment ratings options
ratings_optional
are ratings optional?
ratings_required
are ratings required?
rating_range
range of ratings
rating_choices
choice of ratings
"""
if extra_context is None: extra_context = {}
if not request.POST:
raise Http404, _("Only POSTs are allowed")
try:
options, target, security_hash = request.POST['options'], request.POST['target'], request.POST['gonzo']
except KeyError:
raise Http404, _("One or more of the required fields wasn't submitted")
photo_options = request.POST.get('photo_options', '')
rating_options = normalize_newlines(request.POST.get('rating_options', ''))
if Comment.objects.get_security_hash(options, photo_options, rating_options, target) != security_hash:
raise Http404, _("Somebody tampered with the comment form (security violation)")
# Now we can be assured the data is valid.
if rating_options:
rating_range, rating_choices = Comment.objects.get_rating_options(base64.decodestring(rating_options))
else:
rating_range, rating_choices = [], []
content_type_id, object_id = target.split(':') # target is something like '52:5157'
try:
obj = ContentType.objects.get(pk=content_type_id).get_object_for_this_type(pk=object_id)
except ObjectDoesNotExist:
raise Http404, _("The comment form had an invalid 'target' parameter -- the object ID was invalid")
option_list = options.split(',') # options is something like 'pa,ra'
new_data = request.POST.copy()
new_data['content_type_id'] = content_type_id
new_data['object_id'] = object_id
new_data['ip_address'] = request.META.get('REMOTE_ADDR')
new_data['is_public'] = IS_PUBLIC in option_list
manipulator = PublicCommentManipulator(request.user,
ratings_required=RATINGS_REQUIRED in option_list,
ratings_range=rating_range,
num_rating_choices=len(rating_choices))
errors = manipulator.get_validation_errors(new_data)
# If user gave correct username/password and wasn't already logged in, log them in
# so they don't have to enter a username/password again.
if manipulator.get_user() and not manipulator.get_user().is_authenticated() and 'password' in new_data and manipulator.get_user().check_password(new_data['password']):
from django.contrib.auth import login
login(request, manipulator.get_user())
if errors or 'preview' in request.POST:
class CommentFormWrapper(oldforms.FormWrapper):
def __init__(self, manipulator, new_data, errors, rating_choices):
oldforms.FormWrapper.__init__(self, manipulator, new_data, errors)
self.rating_choices = rating_choices
def ratings(self):
field_list = [self['rating%d' % (i+1)] for i in range(len(rating_choices))]
for i, f in enumerate(field_list):
f.choice = rating_choices[i]
return field_list
comment = errors and '' or manipulator.get_comment(new_data)
comment_form = CommentFormWrapper(manipulator, new_data, errors, rating_choices)
return render_to_response('comments/preview.html', {
'comment': comment,
'comment_form': comment_form,
'options': options,
'target': target,
'hash': security_hash,
'rating_options': rating_options,
'ratings_optional': RATINGS_OPTIONAL in option_list,
'ratings_required': RATINGS_REQUIRED in option_list,
'rating_range': rating_range,
'rating_choices': rating_choices,
}, context_instance=RequestContext(request, extra_context, context_processors))
elif 'post' in request.POST:
# If the IP is banned, mail the admins, do NOT save the comment, and
# serve up the "Thanks for posting" page as if the comment WAS posted.
if request.META['REMOTE_ADDR'] in settings.BANNED_IPS:
mail_admins("Banned IP attempted to post comment", smart_unicode(request.POST) + "\n\n" + str(request.META))
else:
manipulator.do_html2python(new_data)
comment = manipulator.save(new_data)
return HttpResponseRedirect("../posted/?c=%s:%s" % (content_type_id, object_id))
else:
raise Http404, _("The comment form didn't provide either 'preview' or 'post'")
0
Example 47
def register(request, success_url=None,
form_class=RegistrationForm, profile_callback=None,
template_name='registration/registration_form.html',
extra_context=None):
"""
Allow a new user to register an account.
Following successful registration, issue a redirect; by default,
this will be whatever URL corresponds to the named URL pattern
``registration_complete``, which will be
``/accounts/register/complete/`` if using the included URLConf. To
change this, point that named pattern at another URL, or pass your
preferred URL as the keyword argument ``success_url``.
By default, ``registration.forms.RegistrationForm`` will be used
as the registration form; to change this, pass a different form
class as the ``form_class`` keyword argument. The form class you
specify must have a method ``save`` which will create and return
the new ``User``, and that method must accept the keyword argument
``profile_callback`` (see below).
To enable creation of a site-specific user profile object for the
new user, pass a function which will create the profile object as
the keyword argument ``profile_callback``. See
``RegistrationManager.create_inactive_user`` in the file
``models.py`` for details on how to write this function.
By default, use the template
``registration/registration_form.html``; to change this, pass the
name of a template as the keyword argument ``template_name``.
**Required arguments**
None.
**Optional arguments**
``form_class``
The form class to use for registration.
``extra_context``
A dictionary of variables to add to the template context. Any
callable object in this dictionary will be called to produce
the end result which appears in the context.
``profile_callback``
A function which will be used to create a site-specific
profile instance for the new ``User``.
``success_url``
The URL to redirect to on successful registration.
``template_name``
A custom template to use.
**Context:**
``form``
The registration form.
Any extra variables supplied in the ``extra_context`` argument
(see above).
**Template:**
registration/registration_form.html or ``template_name`` keyword
argument.
"""
if request.method == 'POST':
form = form_class(data=request.POST, files=request.FILES)
if form.is_valid():
new_user = form.save(profile_callback=profile_callback)
# success_url needs to be dynamically generated here; setting a
# a default value using reverse() will cause circular-import
# problems with the default URLConf for this application, which
# imports this file.
return HttpResponseRedirect(success_url or reverse('registration_complete'))
else:
form = form_class()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{ 'form': form },
context_instance=context)
0
Example 48
Project: virtmgr Source File: views.py
def pool(request, host_id, pool):
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
kvm_host = Host.objects.get(user=request.user.id, id=host_id)
def add_error(msg, type_err):
error_msg = Log(host_id=host_id,
type=type_err,
message=msg,
user_id=request.user.id
)
error_msg.save()
def get_vms():
try:
vname = {}
for id in conn.listDomainsID():
id = int(id)
dom = conn.lookupByID(id)
vname[dom.name()] = dom.info()[0]
for id in conn.listDefinedDomains():
dom = conn.lookupByName(id)
vname[dom.name()] = dom.info()[0]
return vname
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_networks():
try:
networks = {}
for name in conn.listNetworks():
net = conn.networkLookupByName(name)
status = net.isActive()
networks[name] = status
for name in conn.listDefinedNetworks():
net = conn.networkLookupByName(name)
status = net.isActive()
networks[name] = status
return networks
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def vm_conn():
try:
flags = [libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE]
auth = [flags, creds, None]
uri = 'qemu+tcp://' + kvm_host.ipaddr + '/system'
conn = libvirt.openAuth(uri, auth, 0)
return conn
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
if not kvm_host.login or not kvm_host.passwd:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = request.session['login_kvm']
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = request.session['passwd_kvm']
else:
return -1
return 0
else:
def creds(credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = kvm_host.login
if len(credential[4]) == 0:
credential[4] = credential[3]
elif credential[0] == libvirt.VIR_CRED_PASSPHRASE:
credential[4] = kvm_host.passwd
else:
return -1
return 0
def get_conn_pool(pool):
try:
net = conn.networkLookupByName(pool)
return net
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def pool_start():
try:
net.create()
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def pool_stop():
try:
net.destroy()
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def pool_delete():
try:
net.undefine()
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def net_set_autostart(pool):
try:
net = conn.networkLookupByName(pool)
net.setAutostart(1)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_net_info(get):
try:
if get == "bridge":
return net.bridgeName()
elif get == "status":
return net.isActive()
elif get == "start":
return net.autostart()
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_ipv4_net():
try:
net = conn.networkLookupByName(pool)
xml = net.XMLDesc(0)
addrStr = util.get_xml_path(xml, "/network/ip/@address")
netmaskStr = util.get_xml_path(xml, "/network/ip/@netmask")
netmask = IP(netmaskStr)
gateway = IP(addrStr)
network = IP(gateway.int() & netmask.int())
return IP(str(network) + "/" + netmaskStr)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_ipv4_dhcp_range():
try:
net = conn.networkLookupByName(pool)
xml = net.XMLDesc(0)
dhcpstart = util.get_xml_path(xml, "/network/ip/dhcp/range[1]/@start")
dhcpend = util.get_xml_path(xml, "/network/ip/dhcp/range[1]/@end")
if not dhcpstart or not dhcpend:
return None
return [IP(dhcpstart), IP(dhcpend)]
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def get_ipv4_forward():
try:
xml = net.XMLDesc(0)
fw = util.get_xml_path(xml, "/network/forward/@mode")
forwardDev = util.get_xml_path(xml, "/network/forward/@dev")
return [fw, forwardDev]
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
def create_net_pool(name_pool, forward, ipaddr, netmask, dhcp, s_dhcp, e_dhcp):
try:
xml = """
<network>
<name>%s</name>""" % (name_pool)
if forward == "nat" or "route":
xml += """<forward mode='%s'/>""" % (forward)
xml += """<bridge stp='on' delay='0' />
<ip address='%s' netmask='%s'>""" % (gw_ipaddr, netmask)
if dhcp == "yes":
xml += """<dhcp>
<range start='%s' end='%s' />
</dhcp>""" % (s_dhcp, e_dhcp)
xml += """</ip>
</network>"""
conn.networkDefineXML(xml)
except libvirt.libvirtError as e:
add_error(e, 'libvirt')
return "error"
conn = vm_conn()
if conn == None:
return HttpResponseRedirect('/overview/%s/' % (host_id))
pools = get_networks()
all_vm = get_vms()
errors = []
if pool != 'new_net_pool':
net = get_conn_pool(pool)
bridge = get_net_info('bridge')
status = get_net_info('status')
if status == 1:
start = get_net_info('start')
network = get_ipv4_net()
dhcprange = get_ipv4_dhcp_range()
netmode = get_ipv4_forward()
if request.method == 'POST':
if request.POST.get('new_net_pool',''):
name_pool = request.POST.get('name_pool','')
net_addr = request.POST.get('net_addr','')
forward = request.POST.get('forward','')
dhcp = request.POST.get('dhcp','')
simbol = re.search('[^a-zA-Z0-9\_]+', name_pool)
if len(name_pool) > 20:
msg = _('The name of the network pool must not exceed 20 characters')
errors.append(msg)
if simbol:
msg = _('The name of the network pool must not contain any characters and Russian characters')
errors.append(msg)
if not name_pool:
msg = _('Enter the name of the pool')
errors.append(msg)
if not net_addr:
msg = _('Enter the IP subnet')
errors.append(msg)
try:
netmask = IP(net_addr).strNetmask()
ipaddr = IP(net_addr)
gw_ipaddr = ipaddr[1].strNormal()
start_dhcp = ipaddr[2].strNormal()
end_dhcp = ipaddr[254].strNormal()
except:
msg = _('IP subnet must be 192.168.1.0/24 or 192.168.1.0/26')
errors.append(msg)
if errors:
return render_to_response('network.html', locals())
if not errors:
if create_net_pool(name_pool, forward, gw_ipaddr, netmask, dhcp, start_dhcp, end_dhcp) is "error":
msg = _('Such a pool already exists')
errors.append(msg)
if not errors:
net_set_autostart(name_pool)
net = get_conn_pool(name_pool)
if pool_start() is "error":
msg = _('Pool is created, but when I run the pool fails, you may specify an existing network')
errors.append(msg)
else:
msg = _('Creating a network pool: ')
msg = msg + name_pool
add_error(msg, 'user')
return HttpResponseRedirect('/network/%s/%s/' % (host_id, name_pool))
if errors:
return render_to_response('network.html', locals())
if request.POST.get('stop_pool',''):
msg = _('Stop network pool: ')
msg = msg + pool
pool_stop()
add_error(msg, 'user')
if request.POST.get('start_pool',''):
msg = _('Start network pool: ')
msg = msg + pool
pool_start()
add_error(msg, 'user')
if request.POST.get('del_pool',''):
msg = _('Delete network pool: ')
msg = msg + pool
pool_delete()
add_error(msg, 'user')
return HttpResponseRedirect('/network/%s/' % (host_id))
return HttpResponseRedirect('/network/%s/%s/' % (host_id, pool))
conn.close()
return render_to_response('network.html', locals())
0
Example 49
Project: classic.rhizome.org Source File: views.py
@login_required
def edit(request, type, id):
context = RequestContext(request)
username = request.user.get_profile()
#CHECK THE TYPE, GRAB OBJECT OR CATCH MISSING INFO
if type == 'opportunities':
announcement = get_object_or_404(Opportunity, id=id, is_spam=False)
announcement_form = OpportunityForm(
request.POST or None,
request.FILES or None,
instance=announcement,
initial={'username':username}
)
elif type == 'jobs':
announcement = get_object_or_404(Job, id=id, is_spam=False)
announcement_form = JobForm(
request.POST or None,
request.FILES or None,
instance=announcement,
initial={'username':username}
)
elif type == 'events':
announcement = get_object_or_404(Event, id=id, is_spam=False)
announcement_form = EventForm(
request.POST or None,
request.FILES or None,
instance=announcement,
initial={'username':username}
)
else:
raise Http404
if not announcement.can_edit():
# can only edit if announcement less than 2 wks old...
return HttpResponseRedirect(reverse('announce_index'))
else:
# MAKE SURE THE USER OWNS THE ANNOUNCEMENT
if request.user != announcement.user:
return HttpResponseRedirect(reverse('announce_index'))
else:
# HANDLE THE POST
if request.method == 'POST':
if request.POST.get("form-type") == "opportunity-form":
announcement_form = OpportunityForm(
request.POST,
request.FILES or None,
instance=announcement,
initial={'username':username}
)
if request.POST.get("form-type") == "job-form":
announcement_form = JobForm(
request.POST,
request.FILES or None,
instance=announcement,
initial={'username':username}
)
if request.POST.get("form-type") == "event-form":
announcement_form = EventForm(
request.POST,
request.FILES or None,
instance=announcement,
initial={'username':username}
)
if announcement_form.is_valid():
announcement = announcement_form.save(commit=False)
announcement.user_id = request.user.id
announcement.ip_address = request.META["REMOTE_ADDR"]
if request.POST.get("delete_image"):
if announcement.image:
import os
if os.path.exists(announcement.image.path):
os.remove(announcement.image.path)
announcement.image = None
#save now so can create thumbanail with id in title
announcement.save()
if announcement.image and not announcement.thumbnail:
announcement.thumbnail = create_thumbnail(announcement.image)
announcement.save()
####
# if announcement is not yet published
####
if request.POST.get("status") == "preview":
announcement.status = False
announcement.save()
return HttpResponseRedirect(reverse(preview, kwargs={'type':type, 'id':announcement.id}))
if request.POST.get("status") == "publish":
if type == 'jobs' and not announcement.is_paid() and not request.user.get_profile().is_member():
return HttpResponseRedirect(reverse(job_payment))
if not moderator.process(announcement, request):
announcement.status = True
announcement.save()
send_to_announce_mailing_list(announcement.__class__, announcement, created=True)
return HttpResponseRedirect(reverse(thanks, kwargs={'type':type,'id':announcement.id}))
####
# if announcement is published
####
if request.POST.get("status") == "unpublish":
announcement.status = False
announcement.save()
#return HttpResponseRedirect('/announce/%s/%s/preview/' % (type, announcement.id))
return HttpResponseRedirect(reverse(edit,kwargs={'type':type,'id':announcement.id}))
if request.POST.get("status") == "update":
moderator.process(announcement, request)
#return HttpResponseRedirect('/announce/%s/%s/preview/' % (type, announcement.id))
return HttpResponseRedirect(reverse(thanks,kwargs={'type':type,'id':announcement.id}))
else:
if type == 'opportunities':
announcement_form = OpportunityForm(request.POST)
if type == 'jobs':
announcement_form = JobForm(request.POST)
if type == 'events':
announcement_form = EventForm(request.POST)
return render_to_response(
"announce/submit.html",
{"announcement_form":announcement_form,
"type": type
},
context
)
0
Example 50
Project: splunk-webframework Source File: comments.py
@csrf_protect
@require_POST
def post_comment(request, next=None, using=None):
"""
Post a comment.
HTTP POST is required. If ``POST['submit'] == "preview"`` or if there are
errors a preview template, ``comments/preview.html``, will be rendered.
"""
# Fill out some initial data fields from an authenticated user, if present
data = request.POST.copy()
if request.user.is_authenticated():
if not data.get('name', ''):
data["name"] = request.user.get_full_name() or request.user.get_username()
if not data.get('email', ''):
data["email"] = request.user.email
# Look up the object we're trying to comment about
ctype = data.get("content_type")
object_pk = data.get("object_pk")
if ctype is None or object_pk is None:
return CommentPostBadRequest("Missing content_type or object_pk field.")
try:
model = models.get_model(*ctype.split(".", 1))
target = model._default_manager.using(using).get(pk=object_pk)
except TypeError:
return CommentPostBadRequest(
"Invalid content_type value: %r" % escape(ctype))
except AttributeError:
return CommentPostBadRequest(
"The given content-type %r does not resolve to a valid model." % \
escape(ctype))
except ObjectDoesNotExist:
return CommentPostBadRequest(
"No object matching content-type %r and object PK %r exists." % \
(escape(ctype), escape(object_pk)))
except (ValueError, ValidationError) as e:
return CommentPostBadRequest(
"Attempting go get content-type %r and object PK %r exists raised %s" % \
(escape(ctype), escape(object_pk), e.__class__.__name__))
# Do we want to preview the comment?
preview = "preview" in data
# Construct the comment form
form = comments.get_form()(target, data=data)
# Check security information
if form.security_errors():
return CommentPostBadRequest(
"The comment form failed security verification: %s" % \
escape(str(form.security_errors())))
# If there are errors or if we requested a preview show the comment
if form.errors or preview:
template_list = [
# These first two exist for purely historical reasons.
# Django v1.0 and v1.1 allowed the underscore format for
# preview templates, so we have to preserve that format.
"comments/%s_%s_preview.html" % (model._meta.app_label, model._meta.module_name),
"comments/%s_preview.html" % model._meta.app_label,
# Now the usual directory based template hierarchy.
"comments/%s/%s/preview.html" % (model._meta.app_label, model._meta.module_name),
"comments/%s/preview.html" % model._meta.app_label,
"comments/preview.html",
]
return render_to_response(
template_list, {
"comment": form.data.get("comment", ""),
"form": form,
"next": data.get("next", next),
},
RequestContext(request, {})
)
# Otherwise create the comment
comment = form.get_comment_object()
comment.ip_address = request.META.get("REMOTE_ADDR", None)
if request.user.is_authenticated():
comment.user = request.user
# Signal that the comment is about to be saved
responses = signals.comment_will_be_posted.send(
sender=comment.__class__,
comment=comment,
request=request
)
for (receiver, response) in responses:
if response == False:
return CommentPostBadRequest(
"comment_will_be_posted receiver %r killed the comment" % receiver.__name__)
# Save the comment and signal that it was saved
comment.save()
signals.comment_was_posted.send(
sender=comment.__class__,
comment=comment,
request=request
)
return next_redirect(request, fallback=next or 'comments-comment-done',
c=comment._get_pk_val())