viernes, 26 de mayo de 2017

Creando my Blog con Django IV: creando las vistas y las urls 馃挭

Muy bienvenidos a esta cuarta parte de c贸mo crear nuestro blog con Django!

Una vez llegados  a este punto, nuestros objetivos, por ahora, ser谩n  crear las vistas necesarias para nuestro blog, y definir una url para cada una de las vistas.


¿Pero, qu茅 har谩n nuestras vistas?
   
Nuestras vistas ser谩n m茅todos en python, que  devolver谩n la informaci贸n solicitada en nuestro blog.

Por ejemplo, si queremos incluir la opci贸n de ver un listado de los posts publicados hasta una fecha concreta, debemos crear una vista haciendo uso de su modelo de datos (en este caso el modelo Post creado) con una query que filtre por un rango de fecha.

As铆, como se puede apreciar en el ejemplo, haremos uso de posts y formularios entre otros elementos.

Comenzamos con la creaci贸n de vistas ☺.




                                                      Creando nuestras Vistas 


Para la creaci贸n de nuestras vistas, necesitaremos primero, crear los archivos base.html y
about.html (extensi贸n de base.html) dentro de la carpeta blog en templates.


Dentro de about.html, a帽adimos qu茅 茅ste, es una extensi贸n de base.html:

             {% extends 'blog/base.html' %}


Ahora estamos preparados para acceder a views.py dentro de la aplicaci贸n d贸nde
tenemos que ir a帽adiendo el siguiente c贸digo 馃挭:
 
from django.shortcuts import render 
from blog.models import Post, Comment   #A帽adiendo los modelos a utilizar
from django.views.generic import (TemplateView, #importar vista tipo para templates!
                                  ListView,
                                  DetailView,
                                  CreateView,
                                  UpdateView,
                                  DeleteView,
                                  )
from django.contrib.auth.mixins import LoginRequiredMixin  #referente a comprobar login馃憤
from django.contrib.auth.decorators import login_required
from blog.forms import PostForm, CommentForm  #A帽adiendo forms
from django.urls import reverse_lazy  #obtener url 馃憤


# Create your views here.
class AboutView(TemplateView):
    template_name = 'about.html'   #M茅todo para mostrar un template.


class PostListView(ListView):
    model = Post                       #Mostrar un listado filtrado y ordenado por fecha de publicaci贸n
    def get_queryset(self):        #accediendo al modelo de datos Post
        return Post.objects.filter(published_date_lte=timezone.now()).order_by('-published_date')


class PostDetailView(DetailView):
    model = Post  # Simplemente accede al modelo para mostrarlo


class CreatePostView(LoginRequiredMixin, CreateView):
    login_url ='/login/'   #Para crear un post, necesitamos el login, nuestro formulario
    redirect_field_name ='blog/post_detail.html/' #y acceder, a nuestro modelo Post.
    form_class = PostForm  #Y, debemos de ser capaces de redirigir a los detalles (datos).
    model = Post


class PostUpdateView(LoginRequiredMixin, UpdateView): #Igual que Crear
    login_url ='/login/'
    redirect_field_name ='blog/post_detail.html/'
    form_class = PostForm
    model = Post


class PostDeleteView(LoginRequiredMixin, DeleteView): #Acceder al modelo para borrar datos
    model = Post                                                                     #Acceder a su url a trav茅s del nombre
    success_url = reverse_lazy('post_list') #Para borrar, tienes que estar logado


class DraftListView(LoginRequiredMixin, ListView): #Filtrado por fecha de publicaci贸n nula
    login_url = '/login/'                                                 
    redirect_field_name = '/blog/post_list.html/'
    model = Post
    def get_queryset(self):
        return Post.objects.filter(published_date_isnull=True).order_by('created_date')

  


Bien! Ahora, vamos a crear nuestras urls, pero primero debemos de crear un archivo urls.py
dentro de nuestra aplicaci贸n.




Estableciendo las Urls 


Ahora, en el archivo urls.py de nuestro proyecto, vamos a incluir la urls.py de nuestra aplicaci贸n
(blog) , d贸nde vamos a establecer las urls de nuestras vistas:
       
              from django.conf.urls import url, include
              from django.contrib import admin

              urlpatterns = [
                    url(r'^admin/', admin.site.urls),
                    url(r' ',include('blog.urls')),  
                    ]
         
    
Ahora s铆! Vamos a crear nuestras urls en el urls.py de nuestra aplicaci贸n, y aqu铆 debemos de importar nuestras vistas:

             from django.conf.urls import url
             from blog import views




Y , para cada vista, una url d贸nde, primero definimos nuestra ruta, importamos nuestra vista,
y le asignamos un nombre 馃槈:

   urlpatterns = [
         url(r'^$', views.PostListView.as_view(), name='post_list'),
         url(r'^about/$', views.AboutView.as_view(), name = 'about'),
         url(r'^post/(?P<pk>\d+)$', views.PostDetailView.as_view(), name='post_detail'),
         url(r'^post/new/$',views.CreatePostView.as_view(), name='post_new'),
         url(r'^post/(?P<pk>\d+)/edit/$', views.PostUpdateView.as_view(), name='post_edit'),
         url(r'^post/(?P<pk>\d+)/remove/$', views.PostDeleteView.as_view(), name='post_remove'),
         url(r'^drafts/$', views.DraftListView.as_view(), name='post_draft_list'),
      ]





Pero, ¿Qu茅 es (?P<pk>\d+)?

Es una expresi贸n regular d贸nde basicamente se est谩 uniendo la primary key del objeto a la url.


Si est谩s interesada o interesado en expresiones regulares, la documentaci贸n de python 3 es id贸nea ☺

Bueno, comprueba que no hay ning煤n error en tu proyecto, y nos vemos en la parte V del proyecto.

Gracias y hasta pronto!

Creando my Blog con Django III: estableciendo paths en settings.py 馃挭

Hola a todos! 
Si ya creaste los modelos  en models.py y los formularios en forms. py, est谩s en el punto
adecuado para empezar a estar realmente motivado en avanzar en este proyecto.

Pero, antes de avanzar todo lo que deseamos, tenemos que crear carpetas y establecerlas en settings.py. Nuestra principal tarea constar谩 en establecer d贸nde est谩 el contenido est谩tico (Html, Css, Javascript) de nuestro proyecto 馃憤. Comenzamos!




Creaci贸n de Carpetas y Archivos
 
  • Crear dentro de tu aplicaci贸n, la carpeta static.
  • Crear dentro de la carpeta static las carpetas:
                            * css
                            * js

  • Crear dentro de la carpeta css el archivo  blog.css.
  • Crear una nueva carpeta en tu aplicaci贸n, que se llame templates.

  • Dentro de templates, crear las carpetas:
                          * blog
                          * registration 




Estableciendo en settings.py 


Una vez que hemos creado las carpetas correspondientes, tenemos que decirle a nuestro proyecto 
la ruta para acceder a ellas. As铆, se lo vamos a decir desde settings.py de nuestro proyecto 馃槈
 
  • Desde el archivo settings.py del proyecto, a帽adir debajo la direcci贸n de 
          la carpeta static que es la BASE_DIR unida con 'static' (nombre carpeta):                       
                         STATIC_ROOT = os.path.join(BASE_DIR,'static')
 


  •  Y definimos la direcci贸n de los templates debajo de BASE_DIR:

                 # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
                 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

                 TEMPLATE_DIR = os.path.join(BASE_DIR, 'blog/templates/blog')


  •  En el array de TEMPLATES, vamos a a帽adir la direcci贸n establecida:
                         TEMPLATES = [
                       {
                              'BACKEND': 'django.template.backends.django.DjangoTemplates',
                               'DIRS': [TEMPLATE_DIR,],
                               'APP_DIRS': True,
                               'OPTIONS': {
                                 'context_processors': [
                                     'django.template.context_processors.debug',
                                     'django.template.context_processors.request',
                                     'django.contrib.auth.context_processors.auth',
                                     'django.contrib.messages.context_processors.messages',
                                   ],
                               },
                           },
                      ]



  • Por 煤ltimo, para redirigir a la ra铆z del blog, una vez que hemos accedido a 茅ste:
                       
                      LOGIN_REDIRECT_URL = '/' 



Well done!! Esta es la tarea que ten铆amos encomendado hasta ahora. 

Ya estamos preparados para crear vistas haciendo uso de nuestros formularios, e identificar 茅stas 
con una url. Esto lo trataremos en el IV post☺ .

Much铆simas gracias y hasta pronto! 


         

jueves, 25 de mayo de 2017

Creando my Blog con Django II: los forms o formularios 馃挭

Hola a todos! Tras desarrollar nuestros modelos Post y Comentario, en la primera parte de
Creando my Blog con Django, estamos listos para crear nuestros formularios☺.

Django te permite crearlos desde cero o con un modelForm.

En nuestro caso vamos a crear un formulario para Comentario , y otro para Post, con un modelForm,
haciendo uso de sus respectivos modelos.


As铆, el primer paso es crear dentro de tu aplicaci贸n, el archivo forms.py.

Una vez creado el archivo, dentro de 茅l, vamos a definir nuestros formularios, y para eso  necesitamos importar los forms desde Django, y las clases Post, Comment que se encuentran en el archivo models.py :

       from django import forms
       from blog.models import Post, Comment



Ahora estamos preparados para definir las clases PostForm y CommentForm:

      class PostForm(forms.ModelForm):

      class CommentForm(forms.ModelForm):






Dentro de cada clase, creamos la clase Meta() d贸nde definimos su modelo,
los campos que vamos a coger del modelo, y sus widgets (tipo y atributos):

    # Para class PostForm
    class Meta():
        model = Post
        fields =('author','title','text')
        Widgets = {
           'title': forms.TextInput(attrs = {'class':'textInputClass'}),
           'text' : forms.Textarea(attrs ={'class':'editable medium-editor-textarea postcontent'})
        }



    #Para class CommentForm
    class Meta():
        model = Comment
        fields =('author','text')
        Widgets = {
           'title': forms.TextInput(attrs = {'class':'textInputClass'}),
           'text' : forms.Textarea(attrs ={'class':'editable medium-editor-textarea'})
        }



Comprueba que no aparece ning煤n error al actualizar tu proyecto.  Si lo has conseguido,
enhorabuena!

Como ves, todav铆a no le hemos dado forma est茅tica al blog.
Habr谩 que ir empezando a crear contenido est谩tico, y para eso, te invito a seguir con la tercera parte 馃挭.
Nos vemos en el pr贸ximo post!


mi茅rcoles, 24 de mayo de 2017

Creando my Blog con Django I: los models o modelos 馃挭

Muy bienvenidos a todos a este post, que tratar谩 la creaci贸n de un blog con Django. 

En esta primera parte, vamos a explicar qu茅 es un modelo y c贸mo crearlos para nuestro proyecto ☺.

Pero, si todav铆a no has creado tu primer proyecto y no est谩s seguro de c贸mo hacerlo, te invito a 
pinchar en el siguiente link : instalaci贸n y creaci贸n de un proyecto Django


Bien. Si ya has creado tu proyecto y tu aplicaci贸n, es el momento id贸neo para crear contenido! 


¿Qu茅 ocurre con ese contenido? 
Que parte de este contenido, ser谩 en forma de datos, que  deben de ser guardados en alg煤n lugar de manera persistente, es decir, en nuestra base de datos.


 ¿C贸mo ser谩n guardados? 
C贸mo objetos , es decir, vamos a trabajar con programaci贸n orientada a objetos d贸nde definiremos los modelos a trav茅s de clases, d贸nde  a su vez, definiremos los campos de cada uno.


Para ello, abrimos el archivo model.py de nuestra aplicaci贸n (nuestro blog) :



Importamos las librer铆as que vamos a utilizar  para tomar nuestra zona horaria y la url :

     from django.utils import timezone
     from django.core.urlresolvers import reverse


Creamos el modelo Post (para nuestros Post) que incluye el autor, el t铆tulo, texto,
fecha de creaci贸n y la fecha de publicaci贸n del Post:

    class Post(models.Model):
       author = models.ForeignKey('auth.User')
       title = models. CharField(max_length = 200)
       text = models.TextField()
       create_date = models.DateTimeField(default = timezone.now())
       published_date = models.DateTimeField(blank = True, null = True)



Dentro del modelo Post, creamos la funci贸n publicar, que guarda la fecha de publicaci贸n cogiendo la zona horaria actual:

    def publish(self):
        self.published_date= timezone.now()
        self.save()

Otra  funci贸n que incluir es la que devuelve los comentarios filtrados por aprobados:

    def approve_comments(self):
        return self.comments.filter(approved_comments= True)



Mediante la funci贸n de obtener url para la clase Post, se devuelve la url requerida:

    def get_absolute_url(self):
        return reverse('post_date',kwags={'pk',self.pk})



La 煤ltima funci贸n de nuestra clase, es la que devuelve la cadena de caracteres del t铆tulo:

    def __str__(self):
        return self.title


Bien hecho! Ya hemos definido la clase Post馃憤.  

Referente a la creaci贸n de modelos, tan solo nos queda definir la clase que va a modelar los comentarios de nuestro blog con el post al que pertenece, el autor del comentario, el texto 
o  comentario, el d铆a de su creaci贸n y si el comentario es aprobado (por defecto False):

     class Comment(models.Model):
          post = models.ForeignKey('blog.Post', related_name = 'comments')
          author = models.CharField(max_length = 200)
          text = models.TextField()
          create_date = models.DateTimeField(default = timezone.now())
          approved_comment = models.BooleanField(default = False)


Funciones que incluir en nuestra clase y que son muy parecidas a las mencionadas anteriormente:

      def approved_comments(self):
        models.BooleanField(default=False)
   

      def approve(self):
        self.approved_comment = True
        self.save()

      def get_absolute_url(self):
        return reverse('post_list')

      def __str__(self):
        return self.text


Perfecto! Hemos creado nuestro modelos. ¿Pero lo hemos creado correctamente? Por ahora, 
el error que podemos depurar es de sintaxis.... si accedes a tu proyecto desde la l铆nea de
comandos y tecleas:

        python manage.py runserver 

Si has arrancado el servidor correctamente y ves algo parecido a la siguiente imagen, es decir, la misma que en la anterior vez que lo arrancaste para comprobar la creaci贸n del proyecto, objetivo cumplido chicos 馃槈!


Agradecerte mucho tu tiempo y nos vemos muy pronto en la segunda parte de "Creando my 
Blog con Django 馃挭".



  




Creando my Blog con Django VI: login y logout 馃挭

Hola a todos! Bienvenidos a la sexta parte de "Creando my Blog con Django" ☺. Llegados a este punto, ya habr谩s creado las cor...