def delete(request):
if request.method == "POST":
profile, created = Profile.objects.get_or_create(user=request.user)
old_profile = copy.copy(profile)
old_user = copy.copy(request.user)
# Remove the profile and all the information
Profile.objects.filter(user=request.user).delete()
EmailValidation.objects.filter(user=request.user).delete()
Avatar.objects.filter(user=request.user).delete()
# Remove the e-mail of the account too
request.user.email = ''
request.user.first_name = ''
request.user.last_name = ''
request.user.save()
messages.success(request, _("Your profile information has been removed successfully."), fail_silently=True)
signal_responses = signals.post_signal.send(sender=delete, request=request, extra={'old_profile':old_profile, 'old_user': old_user})
return signals.last_response(signal_responses) or HttpResponseRedirect(reverse("profile_overview"))
template = "userprofile/profile/delete.html"
data = { 'section': 'delete', }
signals.context_signal.send(sender=delete, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def location(request):
"""
Location selection of the user profile
"""
profile, created = Profile.objects.get_or_create(user=request.user)
geoip = hasattr(settings, "GEOIP_PATH")
if geoip and request.method == "GET" and request.GET.get('ip') == "1":
from django.contrib.gis.utils import GeoIP
g = GeoIP()
c = g.city(request.META.get("REMOTE_ADDR"))
if c and c.get("latitude") and c.get("longitude"):
profile.latitude = "%.6f" % c.get("latitude")
profile.longitude = "%.6f" % c.get("longitude")
profile.country = c.get("country_code")
profile.location = unicode(c.get("city"), "latin1")
if request.method == "POST":
form = LocationForm(request.POST, instance=profile)
if form.is_valid():
form.save()
messages.success(request, _("Your profile information has been updated successfully."), fail_silently=True)
signal_responses = signals.post_signal.send(sender=location, request=request, form=form)
last_response = signals.last_response(signal_responses)
if last_response:
return last_response
else:
form = LocationForm(instance=profile)
template = "userprofile/profile/location.html"
data = { 'section': 'location', 'GOOGLE_MAPS_API_KEY': GOOGLE_MAPS_API_KEY,
'form': form, 'geoip': geoip }
signals.context_signal.send(sender=location, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def avatarcrop(request):
"""
Avatar management
"""
avatar = get_object_or_404(Avatar, user=request.user, valid=False)
if not request.method == "POST":
form = AvatarCropForm()
else:
image = Image.open(ContentFile(avatar.image.read()))
form = AvatarCropForm(image, request.POST)
if form.is_valid():
top = int(form.cleaned_data.get('top'))
left = int(form.cleaned_data.get('left'))
right = int(form.cleaned_data.get('right'))
bottom = int(form.cleaned_data.get('bottom'))
if not (top or left or right or bottom):
(width, height) = image.size
if width > height:
diff = (width-height) / 2
left = diff
right = width-diff
bottom = height
else:
diff = (height-width) / 2
top = diff
right = width
bottom = height-diff
box = [ left, top, right, bottom ]
image = image.crop(box)
if hasattr(settings, "AWS_SECRET_ACCESS_KEY"):
f = StringIO()
image.save(f, image.format)
f.seek(0)
avatar.image.delete()
file_ext = image.content_type.split("/")[1] # "image/gif" => "gif"
if file_ext == 'pjpeg':
file_ext = 'jpeg'
avatar.image.save("%s.%s" % (request.user.username, file_ext), ContentFile(f.read()))
else:
image.save(avatar.image.path)
avatar.valid = True
avatar.save()
messages.success(request, _("Your new avatar has been saved successfully."), fail_silently=True)
signal_responses = signals.post_signal.send(sender=avatarcrop, request=request, form=form)
return signals.last_response(signal_responses) or HttpResponseRedirect(reverse("profile_edit_avatar"))
template = "userprofile/avatar/crop.html"
data = { 'section': 'avatar', 'avatar': avatar, 'form': form, \
'DEFAULT_AVATAR_SIZE': DEFAULT_AVATAR_SIZE, 'MIN_AVATAR_SIZE': MIN_AVATAR_SIZE }
signals.context_signal.send(sender=avatarcrop, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def email_validation_reset(request):
"""
Resend the validation email
"""
if request.user.is_authenticated():
try:
resend = EmailValidation.objects.exclude(verified=True).get(user=request.user).resend()
response = "done"
except EmailValidation.DoesNotExist:
response = "failed"
signal_responses = signals.post_signal.send(sender=email_validation_reset, request=request, extra={'response': response})
return signals.last_response(signal_responses) or HttpResponseRedirect(reverse("email_validation_reset_response", args=[response]))
else:
if request.method == 'POST':
form = ResendEmailValidationForm(request.POST)
if form.is_valid():
email = form.cleaned_data.get('email')
try:
resend = EmailValidation.objects.exclude(verified=True).get(email=email).resend()
response = "done"
except EmailValidation.DoesNotExist:
response = "failed"
signal_responses = signals.post_signal.send(sender=email_validation_reset, request=request, extra={'response': response})
return signals.last_response(signal_responses) or HttpResponseRedirect(reverse("email_validation_reset_response", args=[response]))
else:
form = ResendEmailValidationForm()
template = "userprofile/account/email_validation_reset.html"
data = { 'form': form, }
signals.context_signal.send(sender=email_validation_reset, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def register(request):
if request.method == 'POST':
form = _RegistrationForm(request.POST)
if form.is_valid():
newuser = form.save()
signal_responses = signals.post_signal.send(sender=register, request=request, form=form, extra={'newuser': newuser})
return signals.last_response(signal_responses) or HttpResponseRedirect(reverse('signup_complete'))
else:
form = _RegistrationForm()
template = "userprofile/account/registration.html"
data = { 'form': form, }
signals.context_signal.send(sender=register, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def email_validation(request):
"""
E-mail Change form
"""
if request.method == 'POST':
form = EmailValidationForm(request.POST)
if form.is_valid():
EmailValidation.objects.add(user=request.user, email=form.cleaned_data.get('email'))
signal_responses = signals.post_signal.send(sender=email_validation, request=request, form=form)
return signals.last_response(signal_responses) or HttpResponseRedirect(reverse("email_validation_processed"))
else:
form = EmailValidationForm()
template = "userprofile/account/email_validation.html"
data = { 'form': form, }
signals.context_signal.send(sender=email_validation, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def email_validation_process(request, key):
"""
Verify key and change email
"""
if EmailValidation.objects.verify(key=key):
successful = True
else:
successful = False
signal_responses = signals.post_signal.send(sender=email_validation_process, request=request, extra={'key': key, 'successful': successful})
last_response = signals.last_response(signal_responses)
if last_response:
return last_response
template = "userprofile/account/email_validation_done.html"
data = { 'successful': successful, }
signals.context_signal.send(sender=email_validation_process, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def personal(request):
"""
Personal data of the user profile
"""
profile, created = Profile.objects.get_or_create(user=request.user)
if request.method == "POST":
old_profile = copy.copy(profile)
form = ProfileForm(request.POST, instance=profile)
if form.is_valid():
form.save()
messages.success(request, _("Your profile information has been updated successfully."), fail_silently=True)
signal_responses = signals.post_signal.send(sender=personal, request=request, form=form, extra={'old_profile':old_profile})
last_response = signals.last_response(signal_responses)
if last_response:
return last_response
else:
form = ProfileForm(instance=profile)
template = "userprofile/profile/personal.html"
data = { 'section': 'personal', 'GOOGLE_MAPS_API_KEY': GOOGLE_MAPS_API_KEY,
'form': form, }
signals.context_signal.send(sender=personal, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
def avatarchoose(request):
"""
Avatar choose
"""
profile, created = Profile.objects.get_or_create(user = request.user)
images = dict()
if hasattr(settings, "AVATAR_QUOTA"):
request.upload_handlers.insert(0, QuotaUploadHandler())
if request.method == "POST":
form = AvatarForm()
if request.POST.get('keyword'):
keyword = iri_to_uri(request.POST.get('keyword'))
gd_client = gdata.photos.service.PhotosService()
feed = gd_client.SearchCommunityPhotos(query = "%s&thumbsize=72c" % keyword.split(" ")[0], limit='48')
for entry in feed.entry:
images[entry.media.thumbnail[0].url] = entry.content.src
else:
form = AvatarForm(request.POST, request.FILES)
if form.is_valid():
image = form.cleaned_data.get('url') or form.cleaned_data.get('photo')
try:
thumb = Image.open(ContentFile(image.read()))
except:
messages.error(request, _("This image can't be used as an avatar"))
else:
thumb.thumbnail((480, 480), Image.ANTIALIAS)
f = StringIO()
save_img_params = SAVE_IMG_PARAMS.get(thumb.format, {})
try:
thumb.save(f, thumb.format, **SAVE_IMG_PARAMS.get(thumb.format, {}))
except:
thumb.save(f, thumb.format)
f.seek(0)
avatar = Avatar(user=request.user, image="", valid=False)
file_ext = image.content_type.split("/")[1] # "image/gif" => "gif"
if file_ext == 'pjpeg':
file_ext = 'jpeg'
avatar.image.save("%s.%s" % (request.user.username, file_ext), ContentFile(f.read()))
avatar.save()
signal_responses = signals.post_signal.send(sender=avatarchoose, request=request, form=form)
return signals.last_response(signal_responses) or HttpResponseRedirect(reverse("profile_avatar_crop"))
else:
form = AvatarForm()
if DEFAULT_AVATAR:
base, filename = os.path.split(DEFAULT_AVATAR)
filename, extension = os.path.splitext(filename)
generic = "%s/%s.%d%s" % (base, filename, DEFAULT_AVATAR_SIZE, extension)
generic = generic.replace(settings.STATIC_ROOT, settings.STATIC_URL)
else:
generic = ""
template = "userprofile/avatar/choose.html"
data = { 'generic': generic, 'form': form, "images": images,
'AVATAR_WEBSEARCH': AVATAR_WEBSEARCH, 'section': 'avatar',
'DEFAULT_AVATAR_SIZE': DEFAULT_AVATAR_SIZE, 'MIN_AVATAR_SIZE': MIN_AVATAR_SIZE }
signals.context_signal.send(sender=avatarchoose, request=request, context=data)
return render_to_response(template, data, context_instance=RequestContext(request))
