def dashboard(request):
try:
blog = Blog.objects.get(user=request.user)
if not resolve_subdomain(request.META['HTTP_HOST'], blog):
return redirect(f"{blog.useful_domain()}/dashboard")
if request.method == "POST":
# TODO: Implement create Blog
pass
else:
form = BlogForm(instance=blog)
except Blog.DoesNotExist:
blog = Blog(user=request.user,
title=f"{request.user.username}'s blog",
subdomain=slugify(f"{request.user.username}-new"),
content="Hello World!",
created_date=timezone.now())
blog.save()
form = BlogForm(instance=blog)
return render(request, 'dashboard/dashboard.html', {
'form': form,
'blog': blog,
'root': blog.useful_domain
})
def create_blog(request):
if request.method == "GET":
context = {}
return render(request, 'blogs/create_blog.html', context=context)
if request.method == "POST":
blog = Blog()
blog.author = request.user.profile
blog.title = request.POST['title']
blog.text = request.POST['text']
#тэги
tags = request.POST.get('tags').split(
",") #делим строку из формы по запятым
tags = [i.strip() for i in tags] #режем пробелы с обеих сторон
#----------------------------------------------
try:
if any(request.FILES):
blog.image = request.FILES['image']
except:
messages.error(reguest, 'Image is not correct!')
return redirect(reverse('pages:index'))
blog.likes = []
blog.save()
blog.tags.set(
*tags) #назначаем тэги в свежесохранённому блогу(или наоборот)
messages.success(request, 'Blog successfuly created!')
return redirect(reverse('pages:index'))
def post(self, request):
title = request.POST.get('title')
gcontent = request.POST.get('gcontent')
category = request.POST.get('category')
user = request.user
# user = User.objects.get(username=user)
id = user.id
print(title, id, gcontent)
if not all((title, gcontent)):
return render(request, 'user_center.html', {'errmsg': '数据不完整'})
blog = Blog()
blog.title = title
blog.content = gcontent
user = User.objects.get(username=user)
blog.author = user
category = Category.objects.get(name=category)
blog.category = category
# blog=Blog.objects.create(
# title=title,
# # category=category,
# author=id,
#
# )
blog.save()
return redirect(reverse('blogs:personal_center'))
def dashboard(request):
try:
blog = Blog.objects.get(user=request.user)
if not resolve_subdomain(request.META['HTTP_HOST'], blog):
return redirect(f"http://{get_root(blog.subdomain)}/dashboard")
if request.method == "POST":
form = BlogForm(request.POST, instance=blog)
if form.is_valid():
blog_info = form.save(commit=False)
blog_info.save()
else:
form = BlogForm(instance=blog)
except Blog.DoesNotExist:
blog = Blog(user=request.user,
title=f"{request.user.username}'s blog",
subdomain=slugify(f"{request.user.username}-new"),
content="Hello World!",
created_date=timezone.now())
blog.save()
form = BlogForm(instance=blog)
return render(request, 'dashboard/dashboard.html', {
'form': form,
'blog': blog,
'root': get_root(blog.subdomain)
})
def register(request):
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = RegisterForm(request.POST)
print("there is a request")
# check whether it's valid:
if form.is_valid():
user = form.save(commit=False)
user.set_password(form.cleaned_data['password'])
user.save()
blog_id = Blog.objects.count() + 1
user = User.objects.get(username=request.POST.get('username'))
blog = Blog(num=blog_id, writer=user, isDefault=True)
blog.save()
# form.save()
response_data['status'] = 0
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
response_data['status'] = -1
response_data['message'] = list(
form.errors.keys())[0] + ": " + form.errors[list(
form.errors.keys())[0]][0]
print(
HttpResponse(json.dumps(response_data),
content_type="application/json"))
return HttpResponse(json.dumps(response_data),
content_type="application/json")
else:
return HttpResponse(json.dumps(response_data),
content_type="application/json")
def create_blog(request):
user = request.user
profile = Profile.objects.get(user=request.user)
context = {'profile': profile}
if request.method == 'GET':
return render(request, 'blogs/create_blog.html', context=context)
if request.method == 'POST':
title = request.POST['title']
text = request.POST['text']
tags = request.POST['tags']
# blog create
blog = Blog()
blog.title = title
blog.text = text
blog.author = profile
try:
if any(request.FILES):
blog.image = request.FILES['image']
except:
blog.tags.add(tags)
messages.error(request, 'Blog Image is not correct!')
return render(request, 'blog/create_blog.html', context=context)
blog.save()
messages.success(request, 'Blog successfully created!')
return redirect('/profiles/profile/{}'.format(user.username))
def mutate(cls, root, info, project_id, blog):
user = info.context.user
if (user.is_authenticated):
project = Project.objects.get(pk=project_id)
author = User.objects.get(pk=user.id)
if (author in project.members.all()
or author in project.moderators.all()
or author == project.admin):
project_blog = Blog(author=author,
title=blog.title,
is_project_blog=True)
if blog.data is not None:
project_blog.data = blog.data
if blog.tags is not None:
project_blog.tags = blog.tags
if blog.more_info is not None:
project_blog.more_info = blog.more_info
project_blog.save()
project.blogs.add(project_blog)
project.save()
return AddProjectBlogMutation(blog=project_blog)
raise Exception(
"You don't have permissions to perform this action")
raise Exception("You have to be logged in to access api")
def register(request):
if request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.set_password(form.cleaned_data['password'])
user.save()
blog_id = Blog.objects.count() + 1
user = User.objects.get(username=request.POST.get('username'))
blog = Blog(blog_id=blog_id, user=user)
user.default_blog_id = blog_id
user.save()
blog.save()
response = {
"status": 0,
}
else:
response = {
'status': -1,
'message': "some other error occurred"
}
return HttpResponse(json.dumps(response), content_type="application/json")
else:
response = {
"status": -1,
"message": "some error occurred"
}
return HttpResponse(json.dumps(response), content_type="application/json")
def post(self,request):
user = User()
form = UserForm(data=request.POST)
form.instance = user
if form.is_valid():
user.first_name = form.cleaned_data.get('first_name')
user.last_name = form.cleaned_data.get('last_name')
user.email = form.cleaned_data.get('email')
user.username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user.set_password(password)
user.save()
blog = Blog(user=user)
blog.name = form.cleaned_data.get('blog_name')
blog.description = form.cleaned_data.get('blog_description')
blog.save()
# logeamos al usaurio
authenticate_user = authenticate(username=user.username, password=password)
django_login(request, authenticate_user)
# vaciamos el formulario
form = UserForm()
url = reverse("create_post")
message = "User with blog created successfully!"
message += '<a href="{0}">Create you first post</a>'.format(url)
# enviamos mensaje de exito con un enlace al blog que acabamos de crear
messages.success(request, message)
return render(request, "singup_form.html", {'form': form})
def post(self, request):
"""
Recibe los datos del nuevo post los valida y los guarda
:param request: HttpRequest
:return: HttpResponse """
# crear el formulario con los datos del POST
blog_with_user = Blog(owner=request.user)
form = BlogForm(request.POST, instance=blog_with_user)
if form.is_valid():
#crea el post
blog = form.save()
#generar mensaje de exito
msg = "Blog creado con éxito"
# limpiamos el formulario creando uno vacío para pasar a la plantilla
form = BlogForm()
else:
msg = "Ha ocurrido un error al guardar el blog" \
# renderiza la plantilla con el formulario
context = {"form": form, "msg": msg}
# renderiza y devuelve la plantilla
return render(request, 'blogs/new-blog.html', context)
def post(self, request, *args, **kwargs):
blog = Blog(
author=get_user_model().objects.get(pk=request.data.get("author")),
title=request.data.get("title"),
content=request.data.get("content"),
summary=get_summary(request.data.get("content")),
is_published=request.data.get("is_published"),
)
blog.save()
return Response(status=status.HTTP_200_OK)
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
django_login(request, user)
first_blog = Blog(owner=user,
title=user.first_name + ' first Blog')
first_blog.save()
return redirect('home')
context = {'form': form}
return render(request, 'users/login.html', context)
def post(self, request):
new_blog = Blog(author=request.user)
form = BlogForm(request.POST, instance=new_blog)
if form.is_valid():
new_blog = form.save()
messages.success(
request,
'Blog {0} created successfully!'.format(new_blog.name))
form = BlogForm()
return render(request, 'blogs/blog_new.html', {'form': form})
def post(self, request):
blog = Blog()
blog.owner = request.user
form = BlogForm(request.POST, instance=blog)
if form.is_valid():
new_blog = form.save()
messages.success(
request,
'Post creado correctamente con ID {0}'.format(new_blog.pk))
form = BlogForm()
context = {'form': form}
return render(request, 'new-post.html', context)
def post(self, request):
new_blog = Blog()
blog_form = BlogForm(request.user,
request.POST,
request.FILES,
instance=new_blog)
if blog_form.is_valid():
new_blog = blog_form.save()
messages.success(
request, 'El blog {0} se ha creado corretamente!'.format(
new_blog.title))
blog_form = BlogForm(request.user)
return render(request, 'new_blog.html', {'form': blog_form})
def post(self, request):
blog_with_user = Blog(owner=request.user)
form = BlogForm(request.POST, instance=blog_with_user)
self.translate(form)
message = ""
if form.is_valid():
form.save()
form = BlogForm()
message = _("Se ha creado correctamente el blog")
context = {"form": form, "message": message}
return render(request, 'blogs/new_blog.html', context)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
default_blog_name = "Weblog " + user.username
url = "/blogs/" + user.username
blog_default = Blog(description="",
name=default_blog_name,
user=user,
url=url)
blog_default.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def create(self, validated_data):
instance = User()
blog = Blog()
instance.first_name = validated_data.get("first_name")
instance.last_name = validated_data.get("last_name")
instance.username = validated_data.get("username")
instance.email = validated_data.get("email")
instance.set_password(validated_data.get("password"))
instance.save()
blog.blog_title = self.initial_data.get('blog_title')
blog.user = instance
blog.save()
return instance
def post(self, request):
user_post = User()
form = SignUpForm(request.POST, instance= user_post)
if form.is_valid():
user_post.set_password(form.cleaned_data.get("password"))
user_post = form.save()
default_blog_name= "Weblog " + str(user_post.username)
url = "/blogs/" + str(user_post.username)
blog_default = Blog(description="",name="Weblog " + user_post.username,user=user_post, url=url)
blog_default.save()
form = SignUpForm()
message = "User "+user_post.username+" registered successfully! "
message+= "Your default blog name is "+ default_blog_name
messages.success(request, message)
context = {'form': form}
return render(request, "signup_form.html", context)
def post(self, request):
"""
Shows a form to create a new blog
:param request: HttpRequest
:return: HttpRequest
"""
blog_with_owner = Blog()
blog_with_owner.owner = request.user
form = BlogForm(request.POST, instance=blog_with_owner)
if form.is_valid():
new_blog = form.save() # Guarda el objeto y lo devuelve FTW
return redirect('blog_detail',
ownerName=new_blog.owner,
pk=new_blog.pk)
context = {'form': form}
return render(request, 'blogs/new_blog.html', context)
def post(self, request):
"""
Método para cuando el signup viene del método HTTP get
:param request: HttpRquest
:return: render que contruye un HttpResponse con el template indicado
"""
# Mensaje de éxito al crear nuevo usuario
success_message = ''
# Crearemos un Django Form para presentarlo en la plantilla
# Todos los valores del formulario se inicializan con los valores que vienen en el POST
form = SignupForm(request.POST)
# Si el formulario es válido, guardamos usuario
if form.is_valid():
new_user = User.objects.create_user(
form.cleaned_data.get('username'),
form.cleaned_data.get('email'),
form.cleaned_data.get('password'))
new_user.first_name = form.cleaned_data.get('first_name')
new_user.last_name = form.cleaned_data.get('last_name')
new_user.is_staff = False
# Guardamos usuario
new_user.save()
# Creamos blog con el nuevo usuario
blog = Blog()
blog.owner = new_user
blog.save()
# Reseteamos formulario
form = SignupForm()
success_message = 'OK'
# Creamos contexto con mensaje éxito
context = {'signup_form': form, 'success_message': success_message}
# Mandamos respuesta con error a través de la plantilla
return render(request, 'users/registro.html', context)
def create(self, request):
"""
Endpoint de creación de usuario. Guardamos automáticamente también el blog con su nombre de usuario
:param request:
:return:
"""
# Creamos serializador a partir de los datos de la petición. En rest framwork, para evitar request.POST,
# request.GET, etc., se utiliza simplemente data
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
new_user = serializer.save()
# Guardamos blog para el nuevo usuario
user_blog = Blog()
user_blog.owner = new_user
user_blog.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
# Nos definimos previamente un formulario con el valor del usuario que hemos excluido de la página.
new_blog_in = Blog(owner=request.user)
# Coge los datos del formulario y de los ficheros
form = BlogForm(request.POST, instance=new_blog_in)
if form.is_valid():
new_blog_in = form.save()
messages.success(
request,
'Blog {0} creado con éxito!'.format(new_blog_in.title))
# Se limpia el formulario para una nueva inserción
form = BlogForm()
else:
storage = generate_new_html_errors(form.errors)
for msg in storage:
messages.error(request, storage.get(msg))
return render(request, 'blogs/new_blog.html', {'form': form})
def blog_form(request):
if request.method == 'POST':
form = forms.BlogForm(request.POST)
if form.is_valid():
data = form.cleaned_data
if 'id' not in data:
blog = Blog(title=data['title'],
author=data['author'],
content=data['content'])
blog.save()
else:
blog = Blog.object.get(id=data.id)
blog.title = data['title']
blog.author = data['author']
blog.content = data['content']
blog.save()
return HttpResponseRedirect('/blog/list')
else:
form = forms.BlogForm()
return render_to_response('blog_form.html', {'form': form},
context_instance=RequestContext(request))
def post(self, request):
form = SignupForm(request.POST)
self.translate(form)
context = dict()
if form.is_valid():
if User.objects.filter(
username=form.cleaned_data.get("username")).exists():
form.add_error("username", _("El usuario ya existe"))
else:
user = User()
user.username = form.cleaned_data.get("username")
user.set_password(form.cleaned_data.get("password"))
user.first_name = form.cleaned_data.get("first_name")
user.last_name = form.cleaned_data.get("last_name")
user.email = form.cleaned_data.get("email")
try:
user.save()
blog = Blog()
if user.first_name or user.last_name:
blog.name = "Blog de " + user.first_name + " " + user.last_name
else:
blog.name = "Blog de " + user.username
blog.owner = user
blog.save()
url = request.GET.get('next', '/new-post')
return redirect(url)
except Error as err:
form.add_error("__all__",
_("Error en acceso a base de datos"))
print("Error en acceso a base de datos: ", err)
context["form"] = form
return render(request, 'signup.html', context)
def post(self, request):
"""
Procesa el formulario para crear un blog
:param request: objeto HttpRequest
:return: HttpResponse con la respuesta
"""
blog = Blog()
blog.author = request.user
form = BlogForm(request.POST, instance=blog)
if form.is_valid():
# creamos el blog
blog = form.save()
# limpiar el formulario
form = BlogForm()
# Devolvemos un mensaje de OK
messages.success(request, 'Blog created correctly')
return redirect('blogs')
context = {'form': form}
context['title'] = "Create a new Blog"
context['claim'] = 'Create an incredible new blog'
messages.error(request,'Blog could not be created. Please check fields')
return render(request, 'blogs/new-blog.html', context)
def post(self, request):
"""
Procesa el formulario de creación de un blog
:param request: objeto HttpRequest
:return: HttpResponse con respuesta
"""
blog = Blog()
try:
blog.owner = User.objects.get(username=request.user)
except Blog.DoesNotExist:
return HttpResponse('Este usuario no existe', status=404)
form = BlogForm(request.POST, request.FILES, instance=blog)
if form.is_valid():
new_blog = form.save()
form = BlogForm()
messages.success(request, 'Blog creado correctamente')
context = {'form': form}
return render(request, 'blogs/form.html', context)
def post(self, request):
form = BlogForm(request.POST)
if form.is_valid():
blog = Blog()
cleaned_data = form.cleaned_data
blog.name = cleaned_data.get('name')
blog.user = request.user
blog.slug = cleaned_data.get('name').replace(" ", "_")
blog.save()
message = "Post creado con éxito!"
form = BlogForm()
else:
message = "Se ha producido un error"
context = {"form": form, "message": message}
return render(request, 'blogs/new_post.html', context)
def post(self, request):
error_messages = []
form = SignupForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('usr')
password = form.cleaned_data.get('pwd')
email = form.cleaned_data.get('email')
user = User.objects.filter(email=email)
if user.exists():
error_messages.append('Ya existe un usuario con este email')
else:
# creamos el usuario
new_user = form.save()
new_user.set_password(new_user.password)
new_user.save()
form = SignupForm()
if new_user.is_active:
# nos autenticamos
user = authenticate(username=new_user.username, password=new_user.password)
# creamos el blog del usuario
blog = Blog(owner=new_user)
blog.title = 'Blog de ' + new_user.username
blog.save()
# redireccionamos a la página de inicio
django_login(request, user)
url = request.GET.get('next', 'wordplease_home')
return redirect(url)
else:
error_messages.append('El usuario no está activo, contacte con el administrador del sitio.')
context = {
'errors': error_messages,
'signup_form': form
}
return render(request, 'users/signup.html', context)
def blog_form(request):
state = None
if request.method == 'POST':
if Blog.objects.all().exists():
blog_last = Blog.objects.all().order_by('-id')[0]
Blog.id = int(blog_last.id) + 1
else:
Blog.id = 0
new_blog = Blog(
id=Blog.id,
title=request.POST.get('title', ''),
author=request.POST.get('author', ''),
content=request.POST.get('content', ''),
)
new_blog.save()
state = 'success'
con = {
'state': state,
}
return render(request, 'yemian/blog_form.html', con)
