def post(self, request):
if 'image_profile' in request.POST:
type_image_profile = 'image_profile'
elif 'image_cover_profile' in request.POST:
type_image_profile = 'image_cover_profile'
else:
type_image_profile = None
if type_image_profile:
try:
raw_extension = request.POST[type_image_profile].partition('base64,')[0] # Obtenemos solamente la extension inicial de los datos
raw_extension = str(raw_extension).replace(";", "") # Quitamos la copa del final
clean_extension = raw_extension.split('/')[1:][0] # Limpiamos para tener la extension real
photo = request.POST[type_image_profile].partition('base64,')[2]
image_data = base64.b64decode(photo)
if type_image_profile == "image_profile":
request.user.userprofile.image.save('%s.%s' % (get_cleaned_uuid(), clean_extension), ContentFile(image_data), save=True)
cache_key = 'easy_thumb_alias_cache_%s.%s_%s' % ("user", "avatar", request.user.id)
cache.delete(cache_key) # Eliminamos cache
else:
request.user.userprofile.cover_image.save('%s.%s' % (get_cleaned_uuid(), clean_extension), ContentFile(image_data), save=True)
cache_key = 'easy_thumb_alias_cache_%s.%s_%s' % ("user", "cover_image", request.user.id)
cache.delete(cache_key) # Eliminamos cache
msg_level = MSG_SUCCESS
mensaje = "Actualizado correctamente"
except:
msg_level = MSG_ERROR
mensaje = format_sys_errors(sys, with_traceback=True)
else:
msg_level = MSG_ERROR
mensaje = "No se recibió ningún tipo de imagen"
data = create_json_response(message=mensaje, message_level=msg_level)
return JsonResponse(data, safe=True)
def post(self, request):
form = self.form(request.POST, request.FILES)
if form.is_valid():
try:
tags = TagPost.objects.filter(id__in=request.POST.getlist('post_tags'))
except:
tags = None
try:
new_post = form.save(commit=False)
new_post.author = request.user
new_post.slug = slugify(new_post.title)
new_post.save()
if tags:
for tag in tags:
new_post.tags.add(tag)
new_post.save()
messages.success(request, "Gracias por generar una excelente publicación para la comunidad!")
except:
mensaje = format_sys_errors(sys, with_traceback=True)
logger.error(mensaje)
messages.error(request, "Ups! algo salió mal, por favor intenta de nuevo")
else:
messages.error(request, "Error en los datos recibidos")
ctx = {'categories': Category.objects.all(),
'tags': TagPost.objects.all(), 'form': form}
return render(request, self.template_name, ctx)
def post(request):
form = FavoriteForm(request.POST)
is_favorite = False
if form.is_valid():
try:
new_fav = form.save(commit=False)
new_fav.created_by = request.user
new_fav.save()
mensaje = "Favorito generado correctamente"
msg_level = MSG_SUCCESS
is_favorite = True
except IntegrityError:
try:
new_fav = FavoritePost.objects.get(
post=form.cleaned_data['post'],
created_by=request.user)
new_fav.delete()
mensaje = "Se ha eliminado de tus favoritos"
msg_level = MSG_SUCCESS
except LikePost.DoesNotExist:
msg_level = MSG_ERROR
mensaje = "Error al intentar eliminar de tus favoritos"
except:
msg_level = MSG_ERROR
mensaje = format_sys_errors(sys, with_traceback=True)
else:
mensaje = "Error en los datos recibidos"
msg_level = MSG_ERROR
data = create_json_response(message=mensaje,
message_level=msg_level,
is_favorite=is_favorite)
return JsonResponse(data, safe=True)
def post(self, request, token, username):
form = self.form(request.POST)
if form.is_valid():
try:
the_user = User.objects.get(username=username)
except:
the_user = None
try:
my_token = UserTokens.objects.get(user=the_user, token=token)
except:
raise Http404()
if the_user and my_token:
try:
the_user.set_password(form.cleaned_data['password_one'])
the_user.save()
my_token.delete() # Eliminamos el token.
ctx = {'is_error': False, 'form': form, 'changed': True}
except:
mensaje = format_sys_errors(sys, with_traceback=True)
logger.error(mensaje)
ctx = {'is_error': True, 'form': form, 'changed': False}
return render(request, self.template_name, ctx)
else:
return Http404()
else:
ctx = {'is_error': True, 'form': form}
return render(request, self.template_name, ctx)
def send_email(subject, content, to, content_type="text/plain"):
"""
Envía un email con el contenido que se le designe.
:param subject: Título del email.
:param content: contenido o body del mensaje.
:param content_type: tipo de contenido Ej. "text/plain"
:param to: lista de usuarios a los que llegará el email.
:return: True o False para confirmar el envío.
"""
try:
msg = EmailMultiAlternatives(subject=subject, body=content, to=[to])
if content_type == "text/html":
msg.attach_alternative(content, "text/html")
msg.send()
except:
message = format_sys_errors(sys, with_traceback=True)
def image_thumbnail(self):
if self.image:
try:
cache_key = 'easy_thumb_alias_cache_%s.%s_%s' % (
"book", "image", self.id)
thumbnail_cache = cache.get(cache_key)
if thumbnail_cache:
return thumbnail_cache
else:
thumb_url = get_thumbnailer(self.image)['book_image'].url
cache.set(cache_key, thumb_url, 60 * 60)
return thumb_url
except:
logger.error(format_sys_errors(sys, with_traceback=True))
return self.image.url
else:
return "https://www.awm.gov.au/sites/default/files/book-cover-british-official-red-cover.jpg"
def post(self, request, user_id):
if user_id == str(request.user.id):
if 'powers_id' in request.POST:
request.user.userprofile.powers.clear()
arreglo = request.POST.getlist('powers_id')
for my_id in arreglo:
power = Power.objects.get(id=my_id)
request.user.userprofile.powers.add(power)
try:
lazy_obj = LazyUserProfileData(request.POST)
if 'first_name' in request.POST:
request.user.first_name = request.POST['first_name']
request.user.save()
if 'about_me' in request.POST:
lazy_obj.about_me = request.POST['about_me']
if 'website' in request.POST:
lazy_obj.website = request.POST['website']
if 'about_me' in request.POST:
lazy_obj.about_me = request.POST['about_me']
if 'country_code' in request.POST:
lazy_obj.country_code = request.POST['country_code']
if 'twitter' in request.POST:
lazy_obj.twitter = request.POST['twitter']
if 'facebook' in request.POST:
lazy_obj.facebook = request.POST['facebook']
if 'github' in request.POST:
lazy_obj.github = request.POST['github']
if 'gender' in request.POST:
lazy_obj.gender = request.POST['gender']
if 'image' in request.FILES:
request.user.userprofile.image = request.FILES['image']
request.user.userprofile.data = lazy_obj.to_json()
request.user.userprofile.save()
messages.success(request,
'Información actualizada correctamente')
return HttpResponseRedirect(
reverse('account:profile', args=(request.user.id, )))
except:
mensaje = format_sys_errors(sys, with_traceback=True)
messages.warning(request,
'Hubo un error, por favor intenta de nuevo.')
ctx = {'edit': True}
else:
return HttpResponseRedirect(
reverse('account:profile', args=(user_id, )))
return render(request, self.template_name, ctx)
def post(self, request):
from django.contrib.auth.models import User
from pythonizame.apps.account.models import UserProfile
from pythonizame.apps.account.lazymodels import LazyUserProfileData
form = RegisterForm(request.POST)
if form.is_valid():
try:
username = str(form.cleaned_data['username']).replace(" ", "")
email = form.cleaned_data['email']
password = form.cleaned_data['password_one']
new_user = User.objects.create_user(username=username, email=email, password=password)
new_user.is_active = False # Inicialmente no está activado.
new_user.save()
# Ahora creamos su perfil
lazy_data = LazyUserProfileData()
lazy_data.country_code = form.cleaned_data['country_code']
profile = UserProfile()
profile.user = new_user
profile.data = lazy_data.to_json() # Guardamos los datos JSON
# Generamos la imagen del gravatar
url_gravatar = get_url_gravatar(email)
image_stream = urlopen(url_gravatar)
profile.image.save("img_{0}.jpg".format(profile.user.id), ContentFile(image_stream.read()))
profile.save()
# Ahora creamos un token para que active su cuenta
token = UserTokens()
token.user = new_user
token.save()
# Enviamos un correo de confirmacion
to_email = new_user.email
contenido = render_to_string("mail/activation_template.html", {'url_server': settings['URL_SERVER'],
'token': token.token,
'username': new_user.username,
'password': password,
})
send_email("Bienvenido a Pythonízame", content=contenido, to=to_email, content_type="text/html")
# Enviamos la vista para confirmar registro.
ctx = {'is_registered': True, 'with_error': False}
return render(request, self.template_name, ctx)
except:
mensaje = format_sys_errors(sys, with_traceback=True)
ctx = {'with_error': True, 'form': form}
return render(request, self.template_name, ctx)
else:
return render(request, self.template_name, {'form': form})
def paginate_queryset(self, queryset, page_size):
paginator = self.get_paginator(
queryset,
page_size,
orphans=self.get_paginate_orphans(),
allow_empty_first_page=self.get_allow_empty())
page_kwarg = self.page_kwarg
page = self.kwargs.get(page_kwarg) or self.request.GET.get(
page_kwarg) or 1
try:
page_number = int(page)
except ValueError:
page_number = 1 # Si hay un error entonces enviamos la pagina 1
try:
page = paginator.page(page_number)
tupla = (paginator, page, page.object_list, page.has_other_pages())
return tupla
except:
print(format_sys_errors(sys, with_traceback=True))
raise Http404("No se encontró el sitio especificado")
def post(request):
form = LikeForm(request.POST)
is_like = False
if form.is_valid():
try:
new_like = form.save(commit=False)
new_like.created_by = request.user
new_like.save()
mensaje = "Like generado correctamente"
msg_level = MSG_SUCCESS
is_like = True
except IntegrityError:
try:
my_like = LikePost.objects.get(
post=form.cleaned_data['post'],
created_by=request.user)
my_like.delete()
mensaje = "Se ha eliminado tu like"
msg_level = MSG_SUCCESS
except LikePost.DoesNotExist:
msg_level = MSG_ERROR
mensaje = "Error al intentar eliminar el like"
except:
msg_level = MSG_ERROR
mensaje = format_sys_errors(sys, with_traceback=True)
else:
mensaje = "Error en los datos recibidos"
msg_level = MSG_ERROR
try:
num_likes = LikePost.objects.filter(
post__id=request.POST['post']).count()
except:
num_likes = 0
data = create_json_response(message=mensaje,
message_level=msg_level,
is_like=is_like,
num_likes=num_likes)
return JsonResponse(data, safe=True)
