def create_event (request):
if request.method == "POST":
stuff = request.POST.copy ()
stuff["submitter"] = request.user
print "BACON"
form = EventRegisterForm (request.POST)
if form.is_valid ():
event = form.save (commit = False)
event.submitter = request.user
"""
event.start = adjust_datetime_to_timezone (event.start, request.user_profile)
event.end = adjust_datetime_to_timezone (event.end, request.user_profile)
"""
event.save ()
return redirect ("event_details", event.id)
else:
print 'JLKLJFSDKL'
context = {
"form": form,
}
return direct_to_template (request, "create_event.html", context)
elif request.method == "GET":
context = {
"form": EventRegisterForm (),
}
return direct_to_template (request, "create_event.html", context)
return HttpResponseBadRequest()
def json_box(request, manager=None):
try:
coords = get_coordinates(request.GET.get('bbox', ''))
except CoordinateError as e:
return direct_to_template(request, 'routes/error.html',
{'msg' : e.value})
ids = []
for i in request.GET.get('ids', '').split(','):
try:
ids.append(int(i))
except ValueError:
pass # ignore
if not ids:
return HttpResponse('[]', content_type="text/json")
ids = ids[:settings.ROUTEMAP_MAX_ROUTES_IN_LIST]
selquery = """ST_Intersection(st_transform(SetSRID(
'BOX3D(%f %f, %f %f)'::Box3d,4326),900913) , geom)
""" % coords
ydiff = 10*(coords[3]-coords[1])
if ydiff > 1:
selquery = "ST_Simplify(%s, %f)"% (selquery, ydiff*ydiff*ydiff/2)
selquery = "ST_AsGeoJSON(%s)" % selquery
qs = manager.filter(id__in=ids).extra(
select={'way' : selquery}).only('id')
# print qs.query
return direct_to_template(request, 'routes/route_box.json',
{ 'rels' : qs },
mimetype="text/html")
def del_location(request, loc_id):
import re
if(request.user.is_authenticated()):
try:
location = Location.objects.get(pk=loc_id)
if(location.user.id == request.user.id):
err = None
tag = ''
old_tag = location.tag
mus = MovieUser.objects.filter(user = request.user)
for mu in mus:
tags = mu.location
tags_arr = tags.split(',')
final_tags_arr = []
for t in tags_arr:
t = t.strip()
if(t != '' and t != old_tag):
final_tags_arr.append(t)
mu.location = ','.join(final_tags_arr)
mu.save()
location.delete()
return HttpResponseRedirect('/locations/' + str(request.user.id) + '/?info=removed')
else:
return direct_to_template(request, 'err_perms.html', { })
except:
return direct_to_template(request, 'err_404.html', { })
else:
return direct_to_template(request, 'login_req.html', { 'next':'/locations/edit/' + loc_id + '/' })
def api_info(request):
try:
user = _validate_and_get_geniuser(request)
except LoggedInButFailedGetGeniUserError:
return _show_failed_get_geniuser_page(request)
if request.method == 'GET':
return direct_to_template(request, 'control/api_info.html',
{'username' : user.username,
'api_key' : user.api_key,
'msg' : ""})
# This is a POST, so it should be generation of an API key.
if not request.POST.get('generate_api_key', False):
msg = "Sorry, we didn't understand your request."
return direct_to_template(request, 'control/api_info.html',
{'username' : user.username,
'api_key' : user.api_key,
'msg' : msg})
interface.regenerate_api_key(user)
msg = "Your API key has been regenerated. Your old one will no longer work."
msg += " You should update any places you are using the API key"
msg += " (e.g. in programs using the XML-RPC client)."
return direct_to_template(request, 'control/api_info.html',
{'username' : user.username,
'api_key' : user.api_key,
'msg' : msg})
def edit_location(request, loc_id):
import re
if(request.user.is_authenticated()):
try:
location = Location.objects.get(pk=loc_id)
if(location.user.id == request.user.id):
err = None
if(request.POST):
tag = request.POST['tag']
if(tag != ''):
old_tag = location.tag
mus = MovieUser.objects.filter(user = request.user)
for mu in mus:
mu.location = re.sub(old_tag, tag, mu.location)
mu.save()
location.tag = tag
location.save()
return HttpResponseRedirect('/locations/' + str(request.user.id) + '/?info=modded')
else:
err = "You can't leave the location field blank."
return direct_to_template(request, 'movies/edit_location.html', { 'location':location, 'err':err })
else:
return direct_to_template(request, 'err_perms.html', { })
except:
return direct_to_template(request, 'err_404.html', { })
else:
return direct_to_template(request, 'login_req.html', { 'next':'/locations/edit/' + loc_id + '/' })
def list_vms(request, server_id):
if (not request.user.is_superuser):
return simple.direct_to_template(request,
template = 'not_admin.html',
extra_context = {'user':request.user},
)
vmProjects = {}
vmSlices = {}
try:
for vm in VTDriver.getVMsInServer(VTDriver.getServerById(server_id)):
if vm.projectName not in vmProjects:
vmProjects[vm.projectName] = vm.projectId
if vm.sliceName not in vmSlices:
vmSlices[vm.sliceName] = vm.sliceId
except Exception as e:
print e
pass
server = get_object_or_404(VTServer, pk=server_id)
context = { 'vmProjects': vmProjects, 'vmSlices': vmSlices,'server':server}
return simple.direct_to_template(
request,
template="servers/servers_list_vms.html",
extra_context=context,
)
def success_checkout(request):
last = compras_historico_utils.get_last_order_by_user(request.user.email)
if last == None:
return direct_to_template(request, 'success_checkout.html', {'no_orders':"XXX"})
user = page_users_utils.get_user_info(request.user.email)
saldo = user.saldo
if saldo < 0:
saldo = saldo*-1
###WRONG!!!!
nice_metodo = "Paypal"
page_users_utils.add_payment_user(request,request.user.email, saldo, nice_metodo,store=True)
if user.pais == "Portugal":
return direct_to_template(request, 'success_checkout.html',
{'order':last,
'portugal':user.pais,
'negative_client':saldo,
'negative_client_conversion':card_database_utils.real_price_by_credits(saldo,user.pais)})
if user.pais == "Brasil":
return direct_to_template(request, 'success_checkout.html',
{'order':last,
'brasil':user.pais,
'negative_client':saldo,
'negative_client_conversion':card_database_utils.real_price_by_credits(saldo,user.pais)})
return direct_to_template(request, 'success_checkout.html',{'order':last})
def delete_server(request, server_id):
if (not request.user.is_superuser):
return simple.direct_to_template(request,
template = 'not_admin.html',
extra_context = {'user':request.user},
)
if request.method == 'POST':
try:
VTDriver.deleteServer(VTDriver.getServerById(server_id))
return HttpResponseRedirect(reverse('dashboard'))
except Exception as e:
logging.error(e)
e = HttpUtils.processException(e)
return simple.direct_to_template(request,
template = 'servers/delete_server.html',
extra_context = {'user':request.user, 'exception':e, 'next':reverse("admin_servers")},
)
elif request.method == 'GET':
return simple.direct_to_template(request,
template = 'servers/delete_server.html',
extra_context = {'user':request.user, 'next':reverse("admin_servers"),'object':VTDriver.getServerById(server_id)},
)
def action_vm(request, server_id, vm_id, action):
if (not request.user.is_superuser):
return simple.direct_to_template(request,
template = 'not_admin.html',
extra_context = {'user':request.user},
)
if(action == 'list'):
return simple.direct_to_template(
request, template="servers/server_vm_details.html",
extra_context={"vm": VTDriver.getVMbyId(vm_id), "server_id":server_id}
)
elif(action == 'check_status'):
#XXX: Do this function if needed
return simple.direct_to_template(
request, template="servers/list_vm.html",
extra_context={"vm": VM.objects.get(id = vm_id)}
)
elif(action == 'force_update_server'):
InformationDispatcher.forceListActiveVMs(serverID=server_id)
elif(action == 'force_update_vm'):
InformationDispatcher.forceListActiveVMs(vmID=vm_id)
else:
#XXX: serverUUID should be passed in a different way
VTDriver.PropagateActionToProvisioningDispatcher(vm_id, VTServer.objects.get(id=server_id).uuid, action)
#return HttpResponseRedirect(reverse('edit_server', args = [server_id]))
return HttpResponse("")
def view_build(request, typename):
ownerid = request.user.profile.corpid
corpname = request.user.profile.corp
t = get_object_or_404(Type, typeName=typename)
basket = build(ownerid, t)
if basket is None or len(basket) == 0:
return direct_to_template(request, 'industry/build_direct.html',
extra_context={
'tab': 'build',
'corpname': corpname,
'typename': t.typeName,
'totalcost': cost(ownerid, t)})
components = []
for type_, quantity in basket.items():
pu = cost(ownerid, type_)
components.append((type_, quantity, pu, pu * quantity))
components.sort(key=lambda x: x[0].typeName)
totalcost = sum(x[1] * x[2] for x in components)
return direct_to_template(request, 'industry/build_detail.html',
extra_context={
'tab': 'build',
'corpname': corpname,
'typename': t.typeName,
'component_list': components,
'totalcost': totalcost,
'source': basket.note,
})
def profile(request, user_id=None):
user = get_object_or_404(User, pk=user_id)
all_lessons = user.lessons.all()
lesson_paginator = Paginator(all_lessons, 16)
lesson_page = request.GET.get('page')
try:
lessons = lesson_paginator.page(lesson_page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
lessons = lesson_paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
lessons = lesson_paginator.page(lesson_paginator.num_pages)
if request.user.is_authenticated() and user_id in [None, str(request.user.id)]:
profile = request.user.get_profile()
if request.method == "POST":
form = ProfileForm(request.POST, profile=profile)
if form.is_valid():
profile = form.save()
form = ProfileForm(profile=profile)
else:
form = ProfileForm(profile=profile)
cpass_form = PasswordChangeForm(request.user)
return direct_to_template(request, "profile.html", {"lessons": lessons, "u":user, "form": form, "cpass_form":cpass_form})
elif request.user.is_anonymous() and user_id is None:
return HttpResponseRedirect(reverse("account:auth_login"))
else:
user = get_object_or_404(User, pk=user_id, profile__professional_chef=True)
return direct_to_template(request, "chef_profile.html", {"lessons": lessons, "u":user})
def search(request):
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
search = form.cleaned_data['search']
terms = search.split(' ')
# Exact matches
artist_list = Artist.objects.filter(name__icontains=search)
song_list = Song.objects.filter(title__icontains=search)
# Partial matches
for term in terms:
artist_list = artist_list | Artist.objects.filter(
name__icontains=term
)
song_list = song_list | Song.objects.filter(
title__icontains=term
)
genre_list = Genre.objects.filter(name__icontains=search)
return direct_to_template(request, template='search/results.html',
extra_context={
'artist_list': artist_list,
'song_list': song_list,
'genre_list': genre_list,
'form': form,
},)
else:
form = SearchForm()
return direct_to_template(request, 'search/search_form.html',
{'form': form,})
def user_change_pw(request, up):
tn = 'vns/user_change_pw.html'
is_admin = up.user != request.user
Form = AdminChangePasswordForm if is_admin else ChangePasswordForm
if request.method == 'POST':
form = Form(request.POST)
if form.is_valid():
if not is_admin:
old_pw = form.cleaned_data['old_pw']
new_pw1 = form.cleaned_data['new_pw1']
new_pw2 = form.cleaned_data['new_pw2']
if new_pw1 != new_pw2:
messages.error(request, "Try again: the two versions of your new password do not match.")
return direct_to_template(request, tn, { 'form': form, 'un':up.user.username })
if not is_admin and not authenticate(username=up.user.username, password=old_pw):
messages.error(request, "Incorrect current password.")
return direct_to_template(request, tn, { 'form': form, 'un':up.user.username })
up.user.set_password(new_pw1)
up.user.save()
if is_admin:
messages.success(request, "You have successfully updated %s's password." % up.user.username)
else:
messages.success(request, "You have successfully updated your password.")
return HttpResponseRedirect('/user/%s/' % up.user.username)
else:
form = Form()
return direct_to_template(request, tn, { 'form': form, 'un':up.user.username })
def doseries(request, serie_pk):
aantal_deelnemers = models.User.objects.count()
aantal_antwoorden = models.Antwoord.objects.count()
gem_antwoorden = aantal_antwoorden / aantal_deelnemers
serie = models.Serie.objects.get(pk=serie_pk)
vraag = random.choice(serie.vragen.all())
# The items that have already been answered
answered_obj = [x['obj'] for x in request.user.antwoorden.filter(serievraag__serie=serie).values('obj')]
avail_items = serie.items.exclude(objid__in=answered_obj)
if avail_items.count() < 1:
return direct_to_template(request, 'seriescomplete.html',
{'serie': serie,
'aantal_deelnemers': aantal_deelnemers,
'aantal_antwoorden': aantal_antwoorden,
'gem_antwoorden': gem_antwoorden,
})
obj = random.choice(avail_items).obj
util.update_pic_url(obj)
antwoorden = request.user.antwoorden.filter(serievraag__serie=serie)
return direct_to_template(request, 'doseries.html',
{'serie': serie,
'serievraag': vraag,
'vraag': vraag.vraag,
'antwoorden': antwoorden,
'pagename': 'home',
'obj': obj,
'aantal_deelnemers': aantal_deelnemers,
'aantal_antwoorden': aantal_antwoorden,
'gem_antwoorden': gem_antwoorden,
})
def registermethod(request):
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
# Create the user, and set the school in it's profile
kusername = [x for x in username.lower() if x in 'abcdefghijklmnopqrstuvwxyz']
kusername = ''.join(kusername)[:30]
try:
u = models.User.objects.get(username=kusername)
return direct_to_template(request, 'register.html',
{'schools': models.School.objects.all(),
'msg': u'De gebruiker met email: %s bestaat reeds' % username,
})
except models.User.DoesNotExist:
u, created = models.User.objects.get_or_create(username=kusername,
email=username)
u.set_password(password)
u.save()
school = request.POST.get('school')
if school:
school = models.School.objects.get(pk=school)
u_profile = u.get_profile()
u_profile.school = school
u_profile.save()
user = authenticate(username=kusername, password=password)
login(request, user)
return HttpResponseRedirect('/')
return direct_to_template(request, 'register.html',
{'schools': models.School.objects.all()})
def profile(request, creator):
if creator:
creator = get_object_or_None(Profile, username=creator)
if not creator:
return direct_to_template(
request,
'profile/does_not_exists.html',
{
'username': creator,
'all_users': Profile.objects.all()
}
)
else:
creator = request.user
annots = Annotation.objects.filter(
author=creator,
deleted=False,
)
if request.user.is_authenticated():
annots = annots.exclude(~Q(author=request.user), private=True)
return direct_to_template(
request,
'profile/profile.html',
{
'annotations': annots.filter(type='Comment'),
'replies': annots.filter(type='Reply'),
'creator': creator,
'all_users': User.objects.all()
}
)
def practice_list(request, template='memorize/practice_list.html',
paginate_by=None, page=None, allow_empty=True):
practice_list = Practice.objects.filter(user=request.user)\
.order_by('next_practice')
if paginate_by:
paginator = Paginator(practice_list, paginate_by,
allow_empty_first_page=allow_empty)
if not page:
page = request.GET.get('page', 1)
try:
page_number = int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
# Page is not 'last', nor can it be converted to an int.
raise Http404
try:
page_obj = paginator.page(page_number)
except InvalidPage:
raise Http404
return direct_to_template(request, template, {
'paginator': paginator,
'page_obj': page_obj,})
return direct_to_template(request, template, {
'practice_list': practice_list})
def login(request):
" Process a login request. "
vars = {}
# If there is post data - process the form
if request.POST:
form = LoginForm(data=request.POST)
if not form.is_valid():
vars['form'] = form
return direct_to_template(request, 'login.html', vars)
username = form.cleaned_data['email']
password = form.cleaned_data['password']
# Try to auth the user
user = auth.authenticate(username=username, password=password)
if user is None:
vars['form'] = form
vars['error'] = 'Invalid Email and/or Password'
return direct_to_template(request, 'auth/login.html', vars)
# Log the user in to this session
auth.login(request, user)
return HttpResponseRedirect(reverse('sample_project.sample_app.views.clipcloud.profile'))
vars['form'] = LoginForm()
return direct_to_template(request, 'login.html', vars)
def subscription_update( req, info_id ) :
info = MembershipInfo.objects.get(id=info_id)
if info.user != req.user :
path = urlquote(req.get_full_path())
from django.contrib.auth import REDIRECT_FIELD_NAME
tup = settings.LOGIN_URL, REDIRECT_FIELD_NAME, path
return HttpResponseRedirect('%s?%s=%s' % tup)
membership = info.latter_membership()
if membership.has_expired() :
return subscription_renew(req, info_id)
old_email = info.email
if req.method == 'POST' :
form = MembershipInfoForm(req.POST, instance=info)
if form.is_valid() :
info = form.save()
if info.user is not None :
u = info.user
if u.email != info.email :
u.email = info.email
u.save()
if info.email != old_email :
MembershipInfoEmailChange.objects.create(old_email=old_email, info=info)
return direct_to_template(req, "membership/subscription_updated.html", {"membership" : membership})
else :
form = MembershipInfoForm(instance=info)
return direct_to_template(req, "membership/subscription_update.html",
{"form": form, "membership": membership})
def profile_delete(request):
if not request.POST.has_key('delete'):
# Extra sanity-check that this is a POST request
log.error('Received deletion request but was not POST')
message = _("There was a problem with your request to delete this profile.")
return direct_to_template(request, 'profile.html', { 'message':message})
if not request.POST['delete'] == request.user.email:
# And that we're POSTing from our own form (this is a sanity check,
# not a security feature. The current logged-in user profile is always
# the one to be deleted, regardless of the value of 'delete')
log.error('Received deletion request but nickname did not match: received %s but current user is %s' % (request.POST['delete'], request.user.nickname()))
message = _("There was a problem with your request to delete this profile.")
return direct_to_template(request, 'profile.html', { 'message':message})
request.user.get_profile().delete()
# Delete all their books (this is likely to time out for large numbers of books)
documents = EpubArchive.objects.filter(user_archive__user=request.user)
for d in documents:
_delete_document(request, d)
return HttpResponseRedirect('/') # fixme: actually log them out here
def signup(request):
" Process a request for a user to create an account. "
vars = {}
# If a post, process a signup
if request.POST:
# Bind and validate the form
form = SignUpForm(request.POST)
if not form.is_valid():
vars['form'] = form
return direct_to_template(request, 'signup.html', vars)
# Create a new user
user = models.User.objects.create_user(
username=form.cleaned_data['email'],
email=form.cleaned_data['email'],
password=form.cleaned_data['password']
)
# Create a new profile bound to this user
profile = Profile.objects.create(user=user)
# Attempt to authenticate the user and log them in
user.backend = "%s.%s" % (backends.ModelBackend.__module__, backends.ModelBackend.__name__)
auth.login(request, user)
# Redirect user to the profile page
return HttpResponseRedirect(reverse('sample_project.sample_app.views.clipcloud.profile'))
# If this is NOT a post, simple render the signup form and allow the user to sign up
vars['form'] = SignUpForm()
return direct_to_template(request, 'signup.html', vars)
def topology_permitted_user_add(request, tid, topo):
tn = 'vns/topology_add_permitted_user.html'
APUForm = make_apu_form(request.user, topo)
if request.method == 'POST':
form = APUForm(request.POST)
if form.is_valid():
username = form.cleaned_data['usr']
try:
user = db.UserProfile.objects.get(user__username=username, retired=False).user
except db.UserProfile.DoesNotExist:
return direct_to_template(request, tn, {'form':form, 'more_error':'invalid username', 'tid':tid})
if topo.owner == user:
messages.error(request, 'This topology is already owned by %s.' % username)
return HttpResponseRedirect('/topology%d/' % tid)
tuf = db.TopologyUserFilter()
tuf.topology = topo
tuf.user = user
tuf.save()
messages.success(request, "%s (%s) has been added to the permitted users list." % (username, user.get_full_name()))
return HttpResponseRedirect('/topology%d/' % tid)
else:
form = APUForm()
return direct_to_template(request, tn, {'form':form, 'tid':tid })
def dummy_page(request):
"""
It only makes user login if not logged in and the
page forwards back to root :meth:`legals_population_survey`
:url: /pickadish/legals/
"""
if not request.facebook.check_session(request):
return direct_to_template(request, 'presurvey/canvas.fbml', extra_context={'appname': APP_NAME})
else:
# Get the User object for the currently logged in user
user = User.objects.get_current()
logger.debug("Displaying dummy_page with user logged in")
friends_in_app = request.facebook.friends.getAppUsers()
logger.debug("Friends that use the app initial: %s"%friends_in_app)
if len(friends_in_app)>0:
if len(friends_in_app)>10:
friends_in_app = random.sample(friends_in_app,10)
friends = request.facebook.users.getInfo( friends_in_app, ['pic_square'])
else:
friends = []
logger.debug("Friends that use the app after random: %s"%friends)
# User is guaranteed to be logged in, so pass canvas.fbml
# an extra 'fbuser' parameter that is the User object for
# the currently logged in user.
return direct_to_template(request, 'presurvey/canvas.fbml', extra_context={'fbuser': user, 'friends': friends, 'appname': APP_NAME})
def object_mover(request):
"""
Displays and process form for moving objects by their PID to
a different parent PID
:param request: Django request
"""
if request.method == 'POST':
mover_form = MoverForm(request.POST)
if mover_form.is_valid():
collection_pid = mover_form.cleaned_data['collection_pid']
source_pid = mover_form.cleaned_data['source_pid']
repository_move(source_pid,collection_pid)
new_log = RepositoryMovementLog(collection_pid=collection_pid,
source_pid=source_pid)
new_log.save()
message = 'PID %s moved to collection PID %s' % (source_pid,
collection_pid)
return direct_to_template(request,
'repository/index.html',
{'history': RepositoryMovementLog.objects.all(),
'message':message})
else:
mover_form = MoverForm()
return direct_to_template(request,
'repository/index.html',
{'history':RepositoryMovementLog.objects.all(),
'mover_form':mover_form})
def cc(request, run_id):
"""
Operating the test run cc objects, such as add to remove cc from run
Return: Hash
"""
tr = get_object_or_404(TestRun, run_id=run_id)
if request.REQUEST.get('do'):
if not request.REQUEST.get('user'):
return direct_to_template(request, 'run/get_cc.html', {
'test_run': tr,
'message': 'User name or email is required by this operation'
})
try:
user = User.objects.get(
Q(username=request.REQUEST['user'])
| Q(email=request.REQUEST['user'])
)
except ObjectDoesNotExist, error:
return direct_to_template(request, 'run/get_cc.html', {
'test_run': tr,
'message': 'The user you typed does not exist in database'
})
if request.REQUEST['do'] == 'add':
tr.add_cc(user=user)
if request.REQUEST['do'] == 'remove':
tr.remove_cc(user=user)
def projects(request, project_id=None, skill_id=None):
'''View for handling mentorship request category and detail views'''
if request.method == 'POST':
note = request.POST['note']
user = request.user
project = Project.objects.get(pk=project_id)
join = JoinRequest.objects.get_or_create(
project = project,
added_by = user,
note = note)
join.send_notification()
resp = {'message': 'created'}
return HttpResponse(json.dumps(resp), mimetype='json')
if bool(project_id):
project = get_object_or_404(Project, pk=project_id)
return direct_to_template(
request, 'mentorship_detail.html', locals())
projects = Project.objects.filter(
closed=False).select_related(
'sponsor_set', 'added_by')
if request.GET.get('my_projects'):
skill = {'name':'My Projects'}
projects = projects.filter(added_by=request.user)
if bool(skill_id):
skill = Skill.objects.get(pk=skill_id)
projects = projects.filter(skills=skill)
skills = Skill.objects.all()
return direct_to_template(request, 'mentorship_category.html', locals())
def topologytemplate_create(request):
"""Creates a topology template from the template description that's given"""
tn = 'vns/topologytemplate_create.html'
if request.method == 'POST':
form = CreateTopologyTemplateForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
description = form.cleaned_data['description']
rtable = form.cleaned_data['rtable']
readme = form.cleaned_data['readme']
try:
insert_topologytemplate(description=description, rtable=rtable, readme=readme, user=request.user, template_name=name)
except (TopologyArgumentError, TopologySyntaxError, TopologyNameError) as err:
messages.error(request, str(err))
return direct_to_template(request, tn, {'form':form})
messages.success(request, "Successfully created topology template")
return HttpResponseRedirect('/')
else:
messages.error(request, "Invalid form - did you forget to fill in the readme and routing table?")
return HttpResponseRedirect('/')
else:
f = CreateTopologyTemplateForm()
return direct_to_template(request, tn, {'form':f})
def validate_payment_form(self):
payment_form = self.payment_form_class(self.request.POST)
billing_form = self.billing_form_class(self.request.POST)
if self.shipping_form_class:
shipping_form = self.shipping_form_class(self.request.POST)
#if shipping for exists also validate it
if payment_form.is_valid() and billing_form.is_valid() and (not self.shipping_form_class or shipping_form.is_valid()):
if not self.shipping_form_class:
args = payment_form, billing_form
else:
args = payment_form, billing_form, shipping_form
form_data = combine_form_data(*args)
response = process_payment(form_data, self.extra_data)
self.context['response'] = response
if response.is_approved:
return direct_to_template(self.request,
self.success_template,
self.context)
else:
self.context['errors'] = self.processing_error
self.context['payment_form'] = payment_form
self.context['billing_form'] = billing_form
if self.shipping_form_class:
self.context['shipping_form'] = shipping_form
self.context.setdefault('errors', self.form_error)
return direct_to_template(self.request,
self.payment_template,
self.context)
def inscribirse(request, slug):
"""Un usuario puede inscribirse a un envento si no se ha inscrito ya,
está autenticado y el evento está activo"""
user = request.user
evento = get_object_or_404(Evento, slug = slug)
inscripcion = None
if evento.activo:
if request.method == 'GET':
form = InscripcioForm()
else:
form = InscripcioForm(request.POST)
if form.is_valid():
try:
inscripcion = Inscrito.objects.get(user=user, evento = evento)
msg = _("Ja estàs inscrit a l'event")
except Inscrito.DoesNotExist:
inscripcion = Inscrito(user=user, evento=evento,
comentario = form.cleaned_data['comentario'])
inscripcion.en_lista_espera = evento.completo
inscripcion.save()
return redirect('inscripcion-realizada', slug = slug)
return direct_to_template(request, 'evento/inscripcion_evento.html',
{'evento': evento, 'form':form})
else:
msg = _("L'event ja està tancat i no admet més inscripcions")
data = {'msg': msg, 'inscripcion': inscripcion}
return direct_to_template(request, 'evento/message.html', data)
def add_bookmark(request):
"""
This view serves and validates a bookmark form.
If requested via ajax it also returns the drop bookmark form to replace the
add bookmark form.
"""
if request.method == "POST":
form = BookmarkForm(user=request.user, data=request.POST)
if form.is_valid():
bookmark = form.save()
if not request.is_ajax():
request.user.message_set.create(message='Bookmark added')
if request.POST.get('next'):
return HttpResponseRedirect(request.POST.get('next'))
return HttpResponse('Added')
return direct_to_template(request, 'admin_tools/menu/remove_bookmark_form.html', {
'bookmark': bookmark,
'url': bookmark.url,
});
else:
form = BookmarkForm(user=request.user)
return direct_to_template(request, 'admin_tools/menu/form.html', {
'form': form,
'title': 'Add Bookmark',
})
def donate_instantpaymentnotification(request):
return direct_to_template(request,
'texas/donate_instantpaymentnotification.html')
def contact(request):
events = Event.objects.filter(occurrence__end_date__gte=datetime.now())
return direct_to_template(request, 'texas/contact.html', {'events': events})
def comps(request):
return direct_to_template(request, 'texas/comps.html')
def about(request):
return direct_to_template(request, 'texas/about.html')
def test(request):
return direct_to_template(request, 'texas/test.html')
def view_event(request, event_id):
events = Event.objects.filter(pk=event_id)
return direct_to_template(request, 'texas/index.html', {'events': events})
def do_buy(request, occurrences):
code = request.POST.get('code', None)
show = request.GET.get('show', None)
total_tickets = 0
ip_address = request.META['REMOTE_ADDR']
# coupon
coupon = None
cou = request.POST.get("coupon", None)
if cou:
try:
coupon = Coupon.objects.get(key=cou)
if coupon.cap <= coupon.purchaserequest_set.filter(
purchase__isnull=True).count() +\
coupon.purchase_set.count():
return direct_to_template(request, 'texas/buy.html',
{'occurrences': occurrences,
'error': 'Coupon already used!', 'code': code})
except:
return direct_to_template(request, 'texas/buy.html',
{'occurrences': occurrences,
'error': 'Invalid coupon code!', 'code': code})
purchase_request = None
for occurrence in occurrences:
for tier in occurrence.tier_set.all():
tickets_requested = int(
request.POST.get("tickets_%i" % tier.id, 0))
if tickets_requested > 0:
if tier.reservation_required:
if not request.user.is_authenticated():
form = LoginForm()
message = "Please log in before purchasing."
return direct_to_template(request,
'registration/login.html', {'form': form,
'message': message})
tickets_purchased = Ticket.objects.filter(
purchase__user=request.user,
tier__occurrence=occurrence,
purchase__status='P')
tickets_pending = Ticket.objects.filter(
purchase__user=request.user,
tier__occurrence=occurrence,
purchase__status='T',
purchase__expiration_date__gt=datetime.now())
reservations = Reservation.objects.filter(
email=request.user.email, occurrence=occurrence)
reservation_count = 0
for reservation in reservations:
reservation_count += reservation.tickets_granted
all_tickets = tickets_purchased.count() + \
tickets_pending.count() + tickets_requested
if reservation_count < all_tickets:
return direct_to_template(request, 'texas/buy.html',
{'occurrences': occurrences,
'error': 'Reservation required!', 'code': code})
if tier.password != "":
if request.POST.get(
"password_%i" % tier.id, "") != tier.password:
return direct_to_template(request, 'texas/buy.html',
{'occurrences': occurrences,
'error': 'Incorrect password!', 'code': code})
if tier.use_queue and code:
if not use_queue_code(code, tickets_requested):
return direct_to_template(request, 'texas/error.html',
{'message': "Invalid queue code!"})
if tier.is_lottery and code:
if not check_lottery_code(request, code):
return direct_to_template(request, 'texas/error.html',
{'message': "Invalid queue code!"})
if tier.price > 0:
total_tickets += tickets_requested
request_date = datetime.now()
expires = timedelta(minutes=15)
expiration_date = request_date + expires
purchase_request = PurchaseRequest(tier=tier,
ip_address=ip_address,
tickets_requested=tickets_requested,
request_date=request_date,
expiration_date=expiration_date, coupon=coupon,
queue_code=code)
# add donation if present
#donation_amount = request.POST.get("donation_%i" % tier.id, "")
donation_amount = ""
if donation_amount != "":
try:
purchase_request.donation_amount =\
float(donation_amount)
except:
pass
purchase_request.save()
# add options
for option in occurrence.options.all():
opt = request.POST.get("option_%s" % option.id, None)
if opt:
purchase_request.options.add(option)
if total_tickets == 0:
if purchase_request:
purchase_request.delete()
return direct_to_template(request, 'texas/buy.html', {'occurrences':
occurrences, 'error': 'You have not selected anything!',
'code': code, 'show': show})
else:
# purchases were requested
if request.user.is_authenticated():
ip_address = request.META['REMOTE_ADDR']
do_process_requests(ip_address, request.user)
return redirect_to(request, '/buy/purchases/')
else:
return redirect_to(request, '/buy/requests/')
def donate_thanks(request):
return direct_to_template(request, 'texas/donate_thanks.html')
def user_profile(request):
return direct_to_template(request, 'registration/profile.html')
def donate_ohwell(request):
return direct_to_template(request, 'texas/donate_ohwell.html')
vcf = vobjects.next()
if vcf.contents.has_key('email'):
contacts.append((vcf.email.value,
vcf.fn.value))
except Exception, e:
print e
break
for (email, name) in contacts:
sent.append(_send_invite(request.user, email, name))
return direct_to_template(request, "invite/send.html",
dict(send_form=send_form,
import_form=import_form,
sent=sent
))
def _send_invite(sender, email, name):
if User.objects(email=email).count():
return (email, _('User already registered'), False)
invite = Invite(sender=sender,
recipient_email=email,
recipient_name=name)
invite.save()
invite.send()
def amazon_ipn(request):
return direct_to_template(request, 'texas/paypal_cancel.html')
def principal(request, data):
if request.method == 'GET':
#incluye los parametros del get no va a ignorar el lenguaje (solo se usa para memcache)
var_full_path = request.get_full_path()
#incluye hasta la ? y va a ignorar el lenguaje
var_path = request.path
leng = re.findall('^(\/leng-)([a-zA-Z]{3})(\/)', var_path)
if (len(leng) > 0):
leng = leng[0][1].lower()
var_path = var_path[9:]
data = data[9:]
else:
leng = LENGUAJE_PRED
user = users.get_current_user()
#El usuario no administrativo pasa por memcache
if not users.is_current_user_admin():
anterior = memcache.get(var_full_path)
#if (anterior):
# anterior = anterior.replace('__USER__', generarVariablesUsuario(var_full_path, leng), 1)
# anterior = anterior.replace('__USER_BASE__', generarVariablesUsuarioBase(var_full_path, leng), 1)
# return HttpResponse(anterior, content_type='text/html')
#Buscar un template valido para la url
partes = data.split('/')
archivo = None
directorio = None
archivoExistente = None
if (not data in COMMON_TEMPLATES.keys()):
for parte in partes:
#Se elimina la extension
parte = parte.split('.')[0]
if (archivo == None):
archivo = os.path.join(TEMPLATE_DIRS[0], parte + '.html')
directorio = os.path.join(TEMPLATE_DIRS[0], parte)
else:
archivo = os.path.join(directorio, parte + '.html')
directorio = os.path.join(directorio, parte)
if (os.path.isfile(archivo)):
archivoExistente = archivo
break
#se valida la direccion
if (archivoExistente == None):
archivoExistente = 'index.html'
tmpl = os.path.join(TEMPLATE_DIRS[0], archivoExistente)
else:
if ((COMMON_TEMPLATES[data]['admin']
and users.is_current_user_admin())
or not COMMON_TEMPLATES[data]['admin']):
archivo = os.path.join(ROOT_PATH, 'templates/' + data)
archivoExistente = archivo
tmpl = archivo
else:
archivo = os.path.join(ROOT_PATH, 'templates/403.html')
archivoExistente = archivo
tmpl = archivo
#Se lee el template para saber cuales ids se deben buscar de la base de datos
llavesEntidades = []
identificadores = []
module = __import__('models')
todo = procesarTemplate(tmpl, var_path, TEMPLATE_DIRS[0])
for parte in todo['nodos']:
class_ = getattr(module, parte['tipo'])
identificadores.append(ndb.Key(class_, parte['id']))
llavesEntidades = todo['busquedas']
#Se leen las entidades
list_of_entities = ndb.get_multi(identificadores)
dicci = {}
for entidad in list_of_entities:
if entidad is not None:
nombreClase = entidad.__class__.__name__
if not dicci.has_key(nombreClase):
dicci[nombreClase] = {}
dicci[nombreClase][entidad.key.id()] = entidad.to_dict()
entidades = {}
cursores = {}
data_q = request.GET.get('data-q', None)
data_next = request.GET.get('data-next', None)
for llaveEntidad in llavesEntidades:
objeto_busqueda = simplejson.loads(llaveEntidad)
if (data_q == llaveEntidad and not data_next == None):
objeto_busqueda['next'] = data_next
objeto = comun.buscarGQL(objeto_busqueda)
entidades[llaveEntidad] = comun.to_dict(objeto['datos'])
if (objeto.has_key('next')):
cursores[llaveEntidad] = objeto['next']
valAnalytics = ''
if (dicci.has_key('Configuracion')):
millave = 'analytics_' + leng
if (dicci['Configuracion'].has_key('/general')
and dicci['Configuracion']['/general'].has_key(millave)):
valor = dicci['Configuracion']['/general'][millave]
if (not valor is None and len(valor) > 0):
valAnalytics = ANALYTICS.replace('$1', valor)
context = {
'ANALYTICS': valAnalytics,
'admin': users.is_current_user_admin(),
'path': var_path,
'dicci': dicci,
'leng': leng,
'leng_pred': LENGUAJE_PRED,
'user': user,
'entidades': entidades,
'cursores': cursores,
'JS_COMUNES0': JS_COMUNES0,
'JS_COMUNES1': JS_COMUNES1,
'JS_COMUNES2': JS_COMUNES2,
'JS_COMUNES3': JS_COMUNES3,
'DATETIME_NOW': comun.DATETIME_NOW,
'DATETIME_NOW_LAST': comun.DATETIME_NOW_LAST,
'DATETIME_NOW_FIRST': comun.DATETIME_NOW_FIRST,
'DATE_NOW': comun.DATE_NOW
}
respuesta = direct_to_template(request, archivoExistente, context)
if not users.is_current_user_admin():
memcache.set(var_full_path, respuesta.content)
respuesta.content = respuesta.content.decode('utf-8').replace(
'__USER__', generarVariablesUsuario(var_full_path, leng), 1)
respuesta.content = respuesta.content.decode('utf-8').replace(
'__USER_BASE__', generarVariablesUsuarioBase(var_full_path, leng),
1)
return respuesta
password=request.POST['password'])
if user is not None:
if user.is_active:
ip_address = request.META['REMOTE_ADDR']
do_process_requests(ip_address, user)
login(request, user)
if next_url:
return redirect_to(request, next_url)
else:
return redirect_to(request, '/buy/purchases/')
else:
#return direct_to_template(request, 'registration/inactive_account.html')
form = LoginForm()
message = "Your account is not active."
return direct_to_template(request,
'registration/login.html',
{'form': form, 'message': message,
'next_url': next_url})
else:
#return direct_to_template(request, 'registration/invalid_login.html')
form = LoginForm()
message = "Invalid credentials."
return direct_to_template(request, 'registration/login.html',
{'form': form, 'message': message,
'next_url': next_url})
else:
next_url = request.GET.get('next', '')
form = LoginForm()
return direct_to_template(request, 'registration/login.html', {'form':
form, 'next_url': next_url})
def user_confirm(request, user_id, code):
def index(request, url):
page = get_object_or_404(Page, url=url)
return direct_to_template(request, 'minicms/page_detail.html',
{'page': page})
def index(request):
return direct_to_template(request, 'eav/index.html')
def not_found(request):
return HttpResponseNotFound(direct_to_template(request, "404.html"))
def list_person(request):
return direct_to_template(request, 'list.html', {
'objects': Person.objects.all(),
'title': Person._meta.verbose_name,
})
def activate(request,
username,
activation_key,
template_name='userena/activate_fail.html',
success_url=None,
extra_context=None):
"""
Activate a user with an activation key.
The key is a SHA1 string. When the SHA1 is found with an
:class:`UserenaSignup`, the :class:`User` of that account will be
activated. After a successfull activation the view will redirect to
``succes_url``. If the SHA1 is not found, the user will be shown the
``template_name`` template displaying a fail message.
:param username:
String of the username that wants to be activated.
:param activation_key:
String of a SHA1 string of 40 characters long. A SHA1 is always 160bit
long, with 4 bits per character this makes it --160/4-- 40 characters
long.
:param template_name:
String containing the template name that is used when the
``activation_key`` is invalid and the activation failes. Defaults to
``userena/activation_fail.html``.
:param success_url:
Named URL where the user should be redirected to after a succesfull
activation. If not specified, will direct to
``userena_profile_detail`` view.
:param extra_context:
Dictionary containing variables which could be added to the template
context. Default to an empty dictionary.
"""
user = UserenaSignup.objects.activate_user(username, activation_key)
if user:
# Sign the user in.
auth_user = authenticate(identification=user.email,
check_password=False)
login(request, auth_user)
if userena_settings.USERENA_USE_MESSAGES:
messages.success(
request,
_('Your account has been activated and you have been signed in.'
),
fail_silently=True)
if success_url: redirect_to = success_url
else:
redirect_to = reverse('userena_profile_detail',
kwargs={'username': user.username})
return redirect(redirect_to)
else:
if not extra_context: extra_context = dict()
return direct_to_template(request,
template_name,
extra_context=extra_context)
categorie = get_object_or_404(Categorie, link=categorie_link)
# Récupération des différentes publication de la categorie
try:
typepub = getattr(models, "Article")
except AttributeError, e:
publications = ""
else:
publications = typepub.objects.filter(categorie=categorie.id,
online=True)
# Création du contexte
contexte = {
"categorie": categorie,
"articles": publications,
"categorie_arbre": Categorie.objects.get_recursives(categorie)
}
return direct_to_template(request, 'detail.html', contexte)
def view_publication(request, categorie_link, publication_label):
cat = Categorie.objects.get(link=categorie_link)
pub = get_object_or_404(models.Article,
label=publication_label,
categorie=cat)
if (pub.auteur.first_name and pub.auteur.last_name):
auteur = "%s %s" % (pub.auteur.first_name, pub.auteur.last_name)
else:
auteur = pub.auteur.username
if pub.auteur.email:
auteur = "<a href='mailto:%s' title=\"Contacter l'auteur\">%s</a>" % (
pub.auteur.email, auteur)
# Création du contexte
def password_change(request,
username,
template_name='userena/password_form.html',
pass_form=PasswordChangeForm,
success_url=None,
extra_context=None):
""" Change password of user.
This view is almost a mirror of the view supplied in
:func:`contrib.auth.views.password_change`, with the minor change that in
this view we also use the username to change the password. This was needed
to keep our URLs logical (and REST) accross the entire application. And
that in a later stadium administrators can also change the users password
through the web application itself.
:param username:
String supplying the username of the user who's password is about to be
changed.
:param template_name:
String of the name of the template that is used to display the password
change form. Defaults to ``userena/password_form.html``.
:param pass_form:
Form used to change password. Default is the form supplied by Django
itself named ``PasswordChangeForm``.
:param success_url:
Named URL that is passed onto a :func:`reverse` function with
``username`` of the active user. Defaults to the
``userena_password_complete`` URL.
:param extra_context:
Dictionary of extra variables that are passed on the the template. The
``form`` key is always used by the form supplied by ``pass_form``.
**Context**
``form``
Form used to change the password.
"""
user = get_object_or_404(User, username__iexact=username)
form = pass_form(user=user)
if request.method == "POST":
form = pass_form(user=user, data=request.POST)
if form.is_valid():
form.save()
# Send a signal that the password has changed
userena_signals.password_complete.send(sender=None, user=user)
if success_url: redirect_to = success_url
else:
redirect_to = reverse('userena_password_change_complete',
kwargs={'username': user.username})
return redirect(redirect_to)
if not extra_context: extra_context = dict()
extra_context['form'] = form
return direct_to_template(request,
template_name,
extra_context=extra_context)
def response(request, invite_key, answer='y'):
""" When an invite is accepted or declined """
invite = get_object_or_404(Invite, sha=invite_key, response=1)
invite.response = 2 if answer == "y" else 3
invite.sha = "ALREADY_USED"
invite.save()
# Accepted
if answer == 'y':
# User is authenticated, and the user that is asked, than redirect to project
if request.user.is_authenticated(
) and request.user == invite.created_for_user:
invite.project.members.add(request.user)
request.user.message_set.create(
message=_('You have been added to %(project)s.' %
{'project': invite.project.name}))
return HttpResponseRedirect(reverse('project-list'))
# User is authenticated as a different user
elif request.user.is_authenticated() and invite.created_for_user:
invite.project.members.add(invite.created_for_user)
request.user.message_set.create(message=_(
'%(username)s has been added to %(project)s. \
Login as him to go to this project.'
% {
'username': invite.created_for_user.username,
'project': invite.project.name
}))
logout(request)
return HttpResponseRedirect(reverse('user_signin'))
# User is registered but not authenticated
elif invite.created_for_user:
invite.project.members.add(invite.created_for_user)
return HttpResponseRedirect(
reverse('user_signin') + '?next=%(project_url)s' % {
'project_url':
reverse('project-detail',
kwargs={'slug': invite.project.slug})
})
# User is not registered and not authenticated
else:
form = RegistrationFormUniqueEmail(
initial={'email': invite.created_for_email})
return direct_to_template(request,
template='blinvite/pos_response.html',
extra_context={
'form': form,
'project': invite.project
})
# User doesn't want to join the project.
if answer == 'n':
# User is registered.
if invite.created_for_user:
if request.user.is_authenticated():
request.user.message_set.create(message=_(
'You have declined the invitation to %(project)s.' %
{'project': invite.project.name}))
return HttpResponseRedirect(reverse('project-list'))
else:
return direct_to_template(
request, template='blinvite/neg_reg_response.html')
# User is not registered.
else:
return direct_to_template(
request, template='blinvite/neg_anon_response.html')
def signup(request,
signup_form=SignupForm,
template_name='userena/signup_form.html',
success_url=None,
extra_context=None):
"""
Signup of an account.
Signup requiring a username, email and password. After signup a user gets
an email with an activation link used to activate their account. After
successful signup redirects to ``success_url``.
:param signup_form:
Form that will be used to sign a user. Defaults to userena's
:class:`SignupForm`.
:param template_name:
String containing the template name that will be used to display the
signup form. Defaults to ``userena/signup_form.html``.
:param success_url:
String containing the URI which should be redirected to after a
successfull signup. If not supplied will redirect to
``userena_signup_complete`` view.
:param extra_context:
Dictionary containing variables which are added to the template
context. Defaults to a dictionary with a ``form`` key containing the
``signup_form``.
**Context**
``form``
Form supplied by ``signup_form``.
"""
# If no usernames are wanted and the default form is used, fallback to the
# default form that doesn't display to enter the username.
if userena_settings.USERENA_WITHOUT_USERNAMES and (signup_form
== SignupForm):
signup_form = SignupFormOnlyEmail
form = signup_form()
if request.method == 'POST':
form = signup_form(request.POST, request.FILES)
if form.is_valid():
user = form.save()
if success_url: redirect_to = success_url
else:
redirect_to = reverse('userena_signup_complete',
kwargs={'username': user.username})
# A new signed user should logout the old one.
if request.user.is_authenticated():
logout(request)
return redirect(redirect_to)
if not extra_context: extra_context = dict()
extra_context['register_form'] = form
return direct_to_template(request,
template_name,
extra_context=extra_context)
def profile_edit(request,
username,
edit_profile_form=EditProfileForm,
template_name='userena/profile_form.html',
success_url=None,
extra_context=None):
"""
Edit profile.
Edits a profile selected by the supplied username. First checks
permissions if the user is allowed to edit this profile, if denied will
show a 404. When the profile is succesfully edited will redirect to
``success_url``.
:param username:
Username of the user which profile should be edited.
:param edit_profile_form:
Form that is used to edit the profile. The :func:`EditProfileForm.save`
method of this form will be called when the form
:func:`EditProfileForm.is_valid`. Defaults to :class:`EditProfileForm`
from userena.
:param template_name:
String of the template that is used to render this view. Defaults to
``userena/edit_profile_form.html``.
:param success_url:
Named URL which be passed on to a django ``reverse`` function after the
form is successfully saved. Defaults to the ``userena_detail`` url.
:param extra_context:
Dictionary containing variables that are passed on to the
``template_name`` template. ``form`` key will always be the form used
to edit the profile, and the ``profile`` key is always the edited
profile.
**Context**
``form``
Form that is used to alter the profile.
``profile``
Instance of the ``Profile`` that is edited.
"""
user = get_object_or_404(User, username__iexact=username)
profile = user.get_profile()
user_initial = {'first_name': user.first_name, 'last_name': user.last_name}
form = edit_profile_form(instance=profile, initial=user_initial)
if request.method == 'POST':
form = edit_profile_form(request.POST,
request.FILES,
instance=profile,
initial=user_initial)
if form.is_valid():
profile = form.save()
if userena_settings.USERENA_USE_MESSAGES:
messages.success(request,
_('Your profile has been updated.'),
fail_silently=True)
if success_url: redirect_to = success_url
else:
redirect_to = reverse('userena_profile_detail',
kwargs={'username': username})
return redirect(redirect_to)
if not extra_context: extra_context = dict()
extra_context['form'] = form
extra_context['profile'] = profile
return direct_to_template(request,
template_name,
extra_context=extra_context)
def change_request_sent(request):
"""
Displays a confirmation page with instructions on how to follow the
change mail process
"""
return direct_to_template(request, 'mailchange/change_request_sent.html')
def email_change(request,
username,
form=ChangeEmailForm,
template_name='userena/email_form.html',
success_url=None,
extra_context=None):
"""
Change email address
:param username:
String of the username which specifies the current account.
:param form:
Form that will be used to change the email address. Defaults to
:class:`ChangeEmailForm` supplied by userena.
:param template_name:
String containing the template to be used to display the email form.
Defaults to ``userena/email_form.html``.
:param success_url:
Named URL where the user will get redirected to when succesfully
changing their email address. When not suplied will redirect to
``userena_email_complete`` URL.
:param extra_context:
Dictionary containing extra variables that can be used to render the
template. The ``form`` key is always the form supplied by the keyword
argument ``form`` and the ``user`` key by the user whose email address
is being changed.
**Context**
``form``
Form that is used to change the email address supplied by ``form``.
``account``
Instance of the ``Account`` whose email address is about to be changed.
**Todo**
Need to have per-object permissions, which enables users with the correct
permissions to alter the email address of others.
"""
user = get_object_or_404(User, username__iexact=username)
form = ChangeEmailForm(user)
if request.method == 'POST':
form = ChangeEmailForm(user, request.POST, request.FILES)
if form.is_valid():
email_result = form.save()
if success_url: redirect_to = success_url
else:
redirect_to = reverse('userena_email_change_complete',
kwargs={'username': user.username})
return redirect(redirect_to)
if not extra_context: extra_context = dict()
extra_context['form'] = form
return direct_to_template(request,
template_name,
extra_context=extra_context)
def rule_create(request, table_name=None):
errors = list()
formMode = request.POST.get("conditionMode")
tableName = request.POST.get("table")
PreviousPriority = request.POST.get("ppriority")
editing = request.POST.get("editing")
ruleid = request.POST.get("uuid")
ruleCondition = request.POST.get("condition")
ruleDesc = request.POST.get("description")
ruleError = request.POST.get("error_message")
ruleType = request.POST.get("type")
ruleAction = request.POST.get("action")
ruleValue = request.POST.get("value")
rulePriority = request.POST.get("priority")
ruleEnable = request.POST.get("enable")
previousTable = request.POST.get("hidden_name")
expertRule = request.POST.get("expertRule")
newConditions = request.POST.get("conditionID")
saved = request.POST.get("saved")
if rulePriority == 'Last' or rulePriority == '':
priority = None
else:
priority = int(rulePriority)
if formMode == "easy":
#Avoid empty fields
if ruleDesc == "":
errors.append("Description Field is empty")
if ruleError == "":
errors.append("Error Message field is empty")
if ruleCondition == "":
errors.append("Condition field is empty")
try:
str(ruleDesc)
except:
errors.append(
"Only ascii characters are allowed in Description field")
try:
str(ruleError)
except:
errors.append(
"Only ascii characters are allowed in Error Message field")
try:
str(ruleCondition)
except:
errors.append("Only ascii characters are allowed in Conditions")
if request.POST.get("enable") == 'enable':
enable = True
else:
enable = False
if ruleType == "terminal":
ruleType = ""
if saved == None:
saved = False
#Rule String convertion required
if formMode == "easy":
if ruleAction != "None":
strings = "if " + ruleCondition + " then " + ruleValue + " " + ruleType + " do " + ruleAction + " denyMessage " + ruleError + " #" + ruleDesc
else:
strings = "if " + ruleCondition + " then " + ruleValue + " " + ruleType + " denyMessage " + ruleError + " #" + ruleDesc
else:
strings = expertRule
try:
str(expertRule)
except:
errors.append("Only ascii characters are allowed in a Rule")
try:
if errors:
raise Exception("")
if editing == '1':
#Editing Rules Case:
if previousTable == tableName:
try:
RuleTableManager.editRule(strings, enable, priority,
PreviousPriority, tableName)
except Exception as e:
raise e
#else:
#Moving a rule to a different RuleTable --> this is not possible yet
#print 'Changing table...'
#RuleTableManager.AddRule(strings,enable,priority,tableName=tableName)
#print 'successful add to ' + tableName
#RuleTableManager.RemoveRule(None,int(PreviousPriority),'oldTableName')
#print 'remove from ' + previousTable + ' successful'
else:
RuleTableManager.AddRule(strings,
enable,
priority,
tableName=tableName)
return HttpResponseRedirect("/policies")
except Exception as e:
errors.append(e)
errors.insert(
0, "The Rule cannot be generated. Reason(s):"
) #Insterting the main message error in the first position of the table
priority = RuleTableManager.getPriorityList(tableName)
actionList = RuleTableManager.SetActionList(
ruleAction, RuleTableManager.getActionMappings())
priority = RuleTableManager.getPriorityList(tableName)
#if a rule index is the last, insert "LAST" in the rule priority instead the true index.
try:
int(rulePriority)
if int(rulePriority) in priority:
priority.pop(priority.index(int(rulePriority)))
except:
rulePriority = "Last"
if ruleValue == "accept":
value2 = ["deny"]
else:
value2 = ["accept"]
if ruleType == "nonterminal":
type2 = ["terminal"]
else:
ruleType = "terminal"
type2 = ["nonterminal"]
context = {
'user': request.user,
'saved': True,
'CurrentTable': tableName,
'priority': PreviousPriority,
'enabled': ruleEnable,
'load': 'True',
'valueS': ruleValue,
'valueD': value2,
'terminalS': ruleType,
'terminalD': type2,
'errorMsg': ruleError,
'description': ruleDesc,
'condition': " " + ruleCondition + " ",
'ptable': tableName,
'edit': request.POST.get('edit'),
'action': ruleAction,
'actionList': actionList[1],
'PrioritySel': rulePriority,
'priorityList': priority,
'allMappings': RuleTableManager.GetResolverMappings(tableName),
'ConditionMappings': RuleTableManager.getConditionMappings(),
'ActionMappings': RuleTableManager.getActionMappings(),
'errors': errors,
'rule_uuid': ruleid,
}
#if ruleid == "":
return simple.direct_to_template(
request,
template='policyEngine/policy_create.html',
extra_context=context)
def signin(request,
auth_form=AuthenticationForm,
template_name='userena/signin_form.html',
redirect_field_name=REDIRECT_FIELD_NAME,
redirect_signin_function=signin_redirect,
extra_context=None):
"""
Signin using email or username with password.
Signs a user in by combining email/username with password. If the
combination is correct and the user :func:`is_active` the
:func:`redirect_signin_function` is called with the arguments
``REDIRECT_FIELD_NAME`` and an instance of the :class:`User` whois is
trying the login. The returned value of the function will be the URL that
is redirected to.
A user can also select to be remembered for ``USERENA_REMEMBER_DAYS``.
:param auth_form:
Form to use for signing the user in. Defaults to the
:class:`AuthenticationForm` supplied by userena.
:param template_name:
String defining the name of the template to use. Defaults to
``userena/signin_form.html``.
:param redirect_field_name:
Form field name which contains the value for a redirect to the
successing page. Defaults to ``next`` and is set in
``REDIRECT_FIELD_NAME`` setting.
:param redirect_signin_function:
Function which handles the redirect. This functions gets the value of
``REDIRECT_FIELD_NAME`` and the :class:`User` who has logged in. It
must return a string which specifies the URI to redirect to.
:param extra_context:
A dictionary containing extra variables that should be passed to the
rendered template. The ``form`` key is always the ``auth_form``.
**Context**
``form``
Form used for authentication supplied by ``auth_form``.
"""
form = auth_form
if request.method == 'POST':
form = auth_form(request.POST, request.FILES)
if form.is_valid():
identification, password, remember_me = (
form.cleaned_data['identification'],
form.cleaned_data['password'],
form.cleaned_data['remember_me'])
user = authenticate(identification=identification,
password=password)
if user.is_active:
login(request, user)
if remember_me:
request.session.set_expiry(
userena_settings.USERENA_REMEMBER_ME_DAYS[1] * 86400)
else:
request.session.set_expiry(0)
if userena_settings.USERENA_USE_MESSAGES:
messages.success(request,
_('You have been signed in.'),
fail_silently=True)
# Whereto now?
redirect_to = redirect_signin_function(
request.REQUEST.get(redirect_field_name), user)
return redirect(redirect_to)
else:
return redirect(
reverse('userena_disabled',
kwargs={'username': user.username}))
if not extra_context: extra_context = dict()
extra_context['form'] = form
return direct_to_template(request,
template_name,
extra_context=extra_context)
def rule_edit(request, table_name, rule_uuid, context=None):
load = request.POST.get('load')
if not load == 'True':
rule = RuleTableManager.getRuleOrIndexOrIsEnabled(
rule_uuid, 'Rule', table_name)
rulevalues = RuleTableManager.getValue(rule)
ruletypes = RuleTableManager.getType(rule)
#Flag to be able to diferenciate edit state from creating estate
edit = True
actionList = RuleTableManager.SetActionList(
rule, RuleTableManager.getActionMappings())
priorityList = RuleTableManager.SetPriorityList(rule, table_name)
error = str(rule.getErrorMsg())
description = str(rule.getDescription())
return simple.direct_to_template(
request,
template='policyEngine/policy_create.html',
extra_context={
'user':
request.user,
'edit':
edit,
'rule':
rule,
'priority':
RuleTableManager.getRuleOrIndexOrIsEnabled(
rule_uuid, 'Index', table_name),
'enabled':
RuleTableManager.getRuleOrIndexOrIsEnabled(
rule_uuid, 'Enabled', table_name),
'valueS':
rulevalues[0],
'valueD':
rulevalues[1],
'terminalS':
ruletypes[0],
'terminalD':
ruletypes[1],
'rule_uuid':
rule_uuid,
'ptable':
table_name,
'errorMsg':
error,
'description':
description,
'condition':
rule.getConditionDump(),
'action':
actionList[0],
'actionList':
actionList[1],
'PrioritySel':
priorityList[0],
'priorityList':
priorityList[1],
'allMappings':
RuleTableManager.GetResolverMappings(),
'ConditionMappings':
RuleTableManager.getConditionMappings(),
'ActionMappings':
RuleTableManager.getActionMappings(),
'CurrentTable':
table_name
},
)
else:
return rule_create(request, table_name)
def list_question_media(request):
# Handle file upload
context = {}
documents = []
if request.method == 'POST':
form = DocumentForm(request.POST, request.FILES)
if form.is_valid():
docfile = request.FILES['docfile']
question_id = form.cleaned_data['question_id']
question = Question.objects.get(id=question_id)
docfile_name = docfile.name
docfile_name_changed = docfile_name.replace('.','~^~')
question.docs.update({docfile_name_changed:docfile.content_type})
question.image.update({docfile_name_changed +'_url':'/static/display/s_'+docfile_name, docfile_name_changed +'_name': docfile_name, docfile_name_changed +'_content_type':docfile.content_type})
file_read = docfile.file.read()
file_data = base64.b64encode(file_read)
question.image.update({docfile_name_changed +'_data': file_data})
# question.save()
nq = Question(
user = question.user,
date = question.date,
question = question.question,
docs = question.docs,
image = question.image,
audio = question.audio,
other = question.other,
vote_ids = question.vote_ids,
)
question.delete() # todo - there is an update issue here
nq.save()
questions = Question.objects.all()
return render_to_response('question/home.html', {'questions':questions, 'the_user': request.user, 'message': 'Media updated!' })
# Redirect to the document list after POST
# return HttpResponseRedirect(reverse('data.views.list_question_media'))
else:
if 'q' in request.GET:
question_id = request.GET['q']
form = DocumentForm({ 'question_id':question_id,}, hide_condition=True)
question = Question.objects.get(id=question_id)
documents = []
for docname in question.docs:
file_data = question.image[docname+'_data']
file_name = question.image[docname+'_name']
orig_fname = settings.STATIC_ROOT + '/../moma_example/static/display/' + file_name
new_fname = settings.STATIC_ROOT + '/../moma_example/static/display/tn_' + file_name
_decode_image_to_size(file_data, orig_fname, new_fname, basewidth=128)
documents.append({'docfile':{'url':question.image[docname +'_url'], 'name':question.image[docname+'_name'], 'thumb':'/static/display/tn_'+question.image[docname+'_name']}})
context.update({'q': question_id, 'question':question})
# Load documents for the list page
# documents = [{'docfile':{'url':'blaaa', 'name':'Bleee'}}]
context.update( {'documents': documents, 'form': form,})
context.update(csrf(request))
context.update({'the_user': request.user})
return direct_to_template(request, 'question/question_media.html', context)
