Paginación para Posts

Clase 19 de 26 • Curso de Go Avanzado: REST y WebSockets

Carlos Nexans

student•

Una forma de resolver el ejercicio es tomando "page" y "size" de la request, dejando al cliente cliente como el responsable de saber qué quiere leer. Sobre este mecanismo, en nuestra API podemos verificar que estos parámetros cumplan ciertos requisitos, por ejemplo, requerir que el tamaño de página no exceda un límite para evitar estresar la base de datos.

func getIntQueryParam(r *http.Request, key string, defaultVal int) (int, error) {
	query := r.URL.Query()
	queryVals := query[key]
	var val int
	var err error

	if len(queryVals) != 1 {
		val = defaultVal
	} else {
		val, err = strconv.Atoi(queryVals[0])
	}
	return val, err
}

José Antonio De La Paz Fonseca

student•

No sabía que a las bases de datos les daba ansiedad jaja

Juan Carlos García Esquivel

student•

Este ejemplo de la paginación es incorrecto. Si no se envía ningún parámetro, por convención debería retornar la primera página que contiene los posts 1 y 2. Al enviar la página dos, debería retornar el post 3. En este ejemplo, se contempla la página=0, aunque esto no es lo más común.

Carlos Arturo Pimentel

student•

Estimado Néstor, el contexto que se incluye como parámetro en los handlers es Global a la aplicación y común para todos los Handlers, ó cada handler manejaría su propio contexto ?

José Antonio De La Paz Fonseca

student•

El contexto es un tema completamente aparte, lastimosamente es tan hondo que en éste curso no lo incluyeron

Fernando Cordero

student•

Yo cree esta funcion y la implemente en el handler:

func Pagination(pageStr, limitStr string) models.PaginationDTO {
	var err error
	var page = uint64(1)
	var limit = uint64(10)

	if pageStr != "" && limitStr != "" {
		page, err = strconv.ParseUint(pageStr, 10, 64)
		if err != nil {
			fmt.Printf("page is not valid: %v", err)
		}
		limit, err = strconv.ParseUint(limitStr, 10, 64)
		if err != nil {
			fmt.Printf("limit is not valid: %v", err)
		}
	}

	skip := (page - 1) * limit
	return models.PaginationDTO{
		Limit: limit,
		Skip:  skip,
		Page:  page,
	}
}

Fernando Cordero

student•

Yo maneja la paginacion de la siguiente manera:

Cree una funcion propia de la paginacion:

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

2. Implemente asi en el handler:

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

Fernando Cordero

student•

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

Fernando Cordero

student•

Yo maneje la paginación de la siguiente manera:

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

```func ListPosts(*s* server.Server) http.HandlerFunc {  return func(*w* http.ResponseWriter, *r* \*http.Request) {    pageStr := r.URL.Query().Get("page")    limitStr := r.URL.Query().Get("limit")
&#x20;   pagination := utils.Pagination(pageStr, limitStr)    posts, err := repository.ListPosts(r.Context(), \&pagination)
&#x20;   if err != nil {      http.Error(w, err.Error(), http.StatusInternalServerError)      return    }    json.NewEncoder(w).Encode(posts)  }}

Fernando Cordero

student•

Yo maneje la paginacion asi:

1 - Primero cree una funcion que validara y calculara los parametros:

func Pagination(pageStr, limitStr string) models.PaginationDTO {  var err error  var page = uint64(1)  var limit = uint64(10)
  if pageStr != "" && limitStr != "" {    page, err = strconv.ParseUint(pageStr, 10, 64)    if err != nil {      fmt.Printf("page is not valid: %v", err)    }    limit, err = strconv.ParseUint(limitStr, 10, 64)    if err != nil {      fmt.Printf("limit is not valid: %v", err)    }  }
  skip := (page - 1) * limit  return models.PaginationDTO{    Limit: limit,    Skip:  skip,    Page:  page,  }}

```func Pagination(*pageStr*, *limitStr* string) models.PaginationDTO {  var err error  var page = uint64(1)  var limit = uint64(10)
&#x20; if pageStr != "" && limitStr != "" {    page, err = strconv.ParseUint(pageStr, 10, 64)    if err != nil {      fmt.Printf("page is not valid: %v", err)    }    limit, err = strconv.ParseUint(limitStr, 10, 64)    if err != nil {      fmt.Printf("limit is not valid: %v", err)    }  }
&#x20; skip := (page - 1) \* limit  return models.PaginationDTO{    Limit: limit,    Skip:  skip,    Page:  page,  }}


2 - Luego, la implemente en el handler:

```js
func ListPosts(s server.Server) http.HandlerFunc {  return func(w http.ResponseWriter, r *http.Request) {    pageStr := r.URL.Query().Get("page")    limitStr := r.URL.Query().Get("limit")
    pagination := utils.Pagination(pageStr, limitStr)    posts, err := repository.ListPosts(r.Context(), &pagination)
    if err != nil {      http.Error(w, err.Error(), http.StatusInternalServerError)      return    }    json.NewEncoder(w).Encode(posts)  }}
```func ListPosts(*s* server.Server) http.HandlerFunc {  return func(*w* http.ResponseWriter, *r* \*http.Request) {    pageStr := r.URL.Query().Get("page")    limitStr := r.URL.Query().Get("limit")
&#x20;   pagination := utils.Pagination(pageStr, limitStr)    posts, err := repository.ListPosts(r.Context(), \&pagination)
&#x20;   if err != nil {      http.Error(w, err.Error(), http.StatusInternalServerError)      return    }    json.NewEncoder(w).Encode(posts)  }}

func getIntQueryParam(r *http.Request, key string, defaultVal int) (int, error) {
	query := r.URL.Query()
	queryVals := query[key]
	var val int
	var err error

	if len(queryVals) != 1 {
		val = defaultVal
	} else {
		val, err = strconv.Atoi(queryVals[0])
	}
	return val, err
}

func Pagination(pageStr, limitStr string) models.PaginationDTO {
	var err error
	var page = uint64(1)
	var limit = uint64(10)

	if pageStr != "" && limitStr != "" {
		page, err = strconv.ParseUint(pageStr, 10, 64)
		if err != nil {
			fmt.Printf("page is not valid: %v", err)
		}
		limit, err = strconv.ParseUint(limitStr, 10, 64)
		if err != nil {
			fmt.Printf("limit is not valid: %v", err)
		}
	}

	skip := (page - 1) * limit
	return models.PaginationDTO{
		Limit: limit,
		Skip:  skip,
		Page:  page,
	}
}

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

func ListPosts(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		pageStr := r.URL.Query().Get("page")
		limitStr := r.URL.Query().Get("limit")

		pagination := utils.Pagination(pageStr, limitStr)
		posts, err := repository.ListPosts(r.Context(), &pagination)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		json.NewEncoder(w).Encode(posts)
	}
}

```func ListPosts(*s* server.Server) http.HandlerFunc {  return func(*w* http.ResponseWriter, *r* \*http.Request) {    pageStr := r.URL.Query().Get("page")    limitStr := r.URL.Query().Get("limit")
&#x20;   pagination := utils.Pagination(pageStr, limitStr)    posts, err := repository.ListPosts(r.Context(), \&pagination)
&#x20;   if err != nil {      http.Error(w, err.Error(), http.StatusInternalServerError)      return    }    json.NewEncoder(w).Encode(posts)  }}

func Pagination(pageStr, limitStr string) models.PaginationDTO {  var err error  var page = uint64(1)  var limit = uint64(10)
  if pageStr != "" && limitStr != "" {    page, err = strconv.ParseUint(pageStr, 10, 64)    if err != nil {      fmt.Printf("page is not valid: %v", err)    }    limit, err = strconv.ParseUint(limitStr, 10, 64)    if err != nil {      fmt.Printf("limit is not valid: %v", err)    }  }
  skip := (page - 1) * limit  return models.PaginationDTO{    Limit: limit,    Skip:  skip,    Page:  page,  }}

```func Pagination(*pageStr*, *limitStr* string) models.PaginationDTO {  var err error  var page = uint64(1)  var limit = uint64(10)
&#x20; if pageStr != "" && limitStr != "" {    page, err = strconv.ParseUint(pageStr, 10, 64)    if err != nil {      fmt.Printf("page is not valid: %v", err)    }    limit, err = strconv.ParseUint(limitStr, 10, 64)    if err != nil {      fmt.Printf("limit is not valid: %v", err)    }  }
&#x20; skip := (page - 1) \* limit  return models.PaginationDTO{    Limit: limit,    Skip:  skip,    Page:  page,  }}


2 - Luego, la implemente en el handler:

```js
func ListPosts(s server.Server) http.HandlerFunc {  return func(w http.ResponseWriter, r *http.Request) {    pageStr := r.URL.Query().Get("page")    limitStr := r.URL.Query().Get("limit")
    pagination := utils.Pagination(pageStr, limitStr)    posts, err := repository.ListPosts(r.Context(), &pagination)
    if err != nil {      http.Error(w, err.Error(), http.StatusInternalServerError)      return    }    json.NewEncoder(w).Encode(posts)  }}
```func ListPosts(*s* server.Server) http.HandlerFunc {  return func(*w* http.ResponseWriter, *r* \*http.Request) {    pageStr := r.URL.Query().Get("page")    limitStr := r.URL.Query().Get("limit")
&#x20;   pagination := utils.Pagination(pageStr, limitStr)    posts, err := repository.ListPosts(r.Context(), \&pagination)
&#x20;   if err != nil {      http.Error(w, err.Error(), http.StatusInternalServerError)      return    }    json.NewEncoder(w).Encode(posts)  }}

Paginación para Posts

Introducción

Introducción al curso

¿Qué estaremos construyendo?

HTTP y REST

CRUD

REST

Inicialización de módulo e instalación de dependencias

Struct Server

Nuestro primer endpoint

Definiendo el modelo de usuarios

Patrón repository

Registro de usuarios

Implementando el registro

Probando los registros

Autenticación de usuarios

Probando el login

Middleware de validación de autenticación

Implementando el middleware

Modelo Posts

CRUD para Posts

Paginación para Posts

WebSockets

Websockets

Upgrader y Endpoint para Websocket

Struct de Hub para conexiones

Implementando el Broadcast

Cierre

Ejemplo de implementación frontend

Docker file para producción

Siguientes pasos y mejoras