wip adding run pagination

input-output-hk · Jan 17, 2022 · 8222b8c · 8222b8c
1 parent dc0b677
commit 8222b8c
Show file tree

Hide file tree

Showing 6 changed files with 76 additions and 21 deletions.
diff --git a/src/application/component/web/main.go b/src/application/component/web/main.go
@@ -3,6 +3,8 @@ package web
 import (
 	"context"
 	"encoding/json"
+	"fmt"
+	"html"
 	"io"
 	"net/http"
 	"net/url"
@@ -213,7 +215,7 @@ func (self *Web) Start(ctx context.Context) error {
 	muxRouter.HandleFunc("/", self.IndexGet).Methods(http.MethodGet)
 	muxRouter.HandleFunc("/run/{id}/cancel", self.RunIdCancelGet).Methods(http.MethodGet)
 	muxRouter.HandleFunc("/run/{id}", self.RunIdGet).Methods(http.MethodGet)
-	muxRouter.HandleFunc("/run", self.RunGet).Methods(http.MethodGet)
+	muxRouter.HandleFunc("/run", self.RunGet).Queries("offset", "{offset}", "limit", "{limit}").Methods(http.MethodGet)
 	muxRouter.HandleFunc("/action/current", self.ActionCurrentGet).Methods(http.MethodGet)
 	muxRouter.HandleFunc("/action/new", self.ActionNewGet).Methods(http.MethodGet)
 	muxRouter.HandleFunc("/action/{id}", self.ActionIdGet).Methods(http.MethodGet)
@@ -385,11 +387,11 @@ func (self *Web) RunIdGet(w http.ResponseWriter, req *http.Request) {
 }
 
 func getPage(req *http.Request) (*domain.FetchParam, error) {
-	offset, err := strconv.Atoi(mux.Vars(req)["offset"])
+	offset, err := strconv.Atoi(req.FormValue("offset"))
 	if err != nil {
 		return nil, errors.New("offset parameter is invalid, should be positive integer")
 	}
-	limit, err := strconv.Atoi(mux.Vars(req)["limit"])
+	limit, err := strconv.Atoi(req.FormValue("limit"))
 	if err != nil {
 		return nil, errors.New("limit parameter is invalid, should be positive integer")
 	}
@@ -398,15 +400,21 @@ func getPage(req *http.Request) (*domain.FetchParam, error) {
 
 func (self *Web) RunGet(w http.ResponseWriter, req *http.Request) {
 	if fetchParam, err := getPage(req); err != nil {
-		self.ServerError(w, err)
+		self.BadRequest(w, err)
 	} else {
+		self.Logger.Info().Msgf("Page offset: %d - limit: %d", fetchParam.OffSet, fetchParam.Limit)
 		if runs, err := self.RunService.GetAll(fetchParam); err != nil {
 			self.ServerError(w, err)
 		} else {
+
 			type RunWrapper struct {
 				*domain.Run
 				Action *domain.Action
 			}
+			type ResponseWrapper struct {
+				Runs []RunWrapper
+				Page domain.PageResponse
+			}
 
 			runWrappers := make([]RunWrapper, len(runs.Runs))
 			for i, run := range runs.Runs {
@@ -420,8 +428,20 @@ func (self *Web) RunGet(w http.ResponseWriter, req *http.Request) {
 					}
 				}
 			}
+			responseWrapper := &ResponseWrapper{
+				Runs: runWrappers,
+				Page: domain.PageResponse{
+					PageNumber: runs.FetchParamResponse.PageNumber,
+				},
+			}
+			if runs.FetchParamResponse.PrevOffSet != nil {
+				responseWrapper.Page.PrevPage = html.UnescapeString(fmt.Sprintf(`run/?limit=%d&offset=%d`, fetchParam.Limit, *runs.FetchParamResponse.PrevOffSet))
+			}
+			if runs.FetchParamResponse.NextOffSet != nil {
+				responseWrapper.Page.NextPage = html.UnescapeString(fmt.Sprintf(`run/?limit=%d&offset=%d`, fetchParam.Limit, *runs.FetchParamResponse.NextOffSet))
+			}
 
-			if err := render("run/index.html", w, runWrappers); err != nil {
+			if err := render("run/index.html", w, responseWrapper); err != nil {
 				self.ServerError(w, err)
 			}
 		}
@@ -462,6 +482,7 @@ func (self *Web) ApiActionDefinitionSourceNameIdGet(w http.ResponseWriter, req *
 }
 
 func (self *Web) ApiRunGet(w http.ResponseWriter, req *http.Request) {
+	self.Logger.Info().Msg("When is called???")
 	if fetchParam, err := getPage(req); err != nil {
 		self.ServerError(w, err)
 	} else {

diff --git a/src/application/component/web/template.go b/src/application/component/web/template.go
@@ -31,6 +31,10 @@ func (self *Web) NotFound(w http.ResponseWriter, err error) {
 	http.Error(w, err.Error(), http.StatusNotFound)
 }
 
+func (self *Web) BadRequest(w http.ResponseWriter, err error) {
+	http.Error(w, err.Error(), http.StatusBadRequest)
+}
+
 func (self *Web) Error(w http.ResponseWriter, err error, status int) {
 	self.Logger.Err(err)
 	http.Error(w, err.Error(), status)

diff --git a/src/application/component/web/templates/run/index.html b/src/application/component/web/templates/run/index.html
@@ -12,7 +12,7 @@
 			</tr>
 		</thead>
 		<tbody>
-			{{range .}}
+			{{range .Runs}}
 				<tr>
 					{{with .Action}}
 						<td>
@@ -47,4 +47,21 @@
 			{{end}}
 		</tbody>
 	</table>
+	<nav aria-label="...">
+		<ul class="pagination justify-content-center">
+
+			<li class="page-item">
+				<a class="page-link" href="{{.Page.PrevPage}}">Previous</a>
+			</li>
+
+			<li class="page-item active" aria-current="page">
+				<a class="page-link" href="#"> <span class="sr-only">{{.Page.PageNumber}}</span></a>
+			</li>
+
+			<li class="page-item">
+				<a class="page-link" href="{{.Page.NextPage}}">Next</a>
+			</li>
+
+		</ul>
+	</nav>
 {{end}}
diff --git a/src/application/service/run.go b/src/application/service/run.go
@@ -99,14 +99,22 @@ func (self *runService) GetAll(fetchParam *domain.FetchParam) (*domain.FetchRuns
 		self.logger.Err(err).Msgf("fail to fetch runs with offset %s and limit %s", fetchParam.OffSet, fetchParam.Limit)
 		return nil, err
 	} else {
-		size := len(runs)
-		return &domain.FetchRunsResponse{
+		var fetchParamResponse = &domain.FetchRunsResponse{
 			Runs: runs,
-			Pagination: domain.PageResponse{
-				NextOffSet: fetchParam.OffSet + fetchParam.Limit,
-				LastPage:   size > fetchParam.Limit,
+			FetchParamResponse: domain.FetchParamResponse{
+				PageNumber: fetchParam.OffSet / fetchParam.Limit,
 			},
-		}, nil
+		}
+		if (fetchParam.OffSet - fetchParam.Limit) > 0 {
+			prevOffSet := fetchParam.OffSet - fetchParam.Limit
+			fetchParamResponse.FetchParamResponse.PrevOffSet = &prevOffSet
+		}
+		sizePage := len(runs)
+		if sizePage == (fetchParam.Limit + 1) {
+			nextOffSet := fetchParam.OffSet + fetchParam.Limit
+			fetchParamResponse.FetchParamResponse.NextOffSet = &nextOffSet
+		}
+		return fetchParamResponse, nil
 	}
 }
 

diff --git a/src/domain/types.go b/src/domain/types.go
@@ -165,16 +165,23 @@ type Run struct {
 }
 
 type FetchRunsResponse struct {
-	Runs []*Run
-	Pagination PageResponse
+	Runs               []*Run
+	FetchParamResponse FetchParamResponse
 }
 
 type PageResponse struct {
-	NextOffSet int
-	LastPage bool
+	PageNumber int
+	PrevPage   string
+	NextPage   string
 }
 
 type FetchParam struct {
-	Limit int
+	Limit  int
 	OffSet int
 }
+
+type FetchParamResponse struct {
+	PageNumber int
+	PrevOffSet *int
+	NextOffSet *int
+}
diff --git a/src/infrastructure/persistence/run.go b/src/infrastructure/persistence/run.go
@@ -39,13 +39,11 @@ func (a *runRepository) GetByActionId(id uuid.UUID) (runs []*domain.Run, err err
 }
 
 func (a *runRepository) GetAll(fetchParam *domain.FetchParam) (instances []*domain.Run, err error) {
-	from := fetchParam.OffSet
-	to := fetchParam.Limit + fetchParam.Limit + 1
 	err = pgxscan.Select(
 		context.Background(), a.DB, &instances,
 		`SELECT * FROM run ORDER BY created_at DESC LIMIT $1 OFFSET $2`,
-		to,
-		from,
+		fetchParam.Limit+1,
+		fetchParam.OffSet,
 	)
 	return
 }