From 1a11555075f271ac4e329327a49d797806a1c6a6 Mon Sep 17 00:00:00 2001 From: Jan Bader Date: Sat, 20 Aug 2022 22:23:42 +0000 Subject: [PATCH] Continue migration to echo --- server/account.go | 47 ++++++++++++---------------- server/admin.go | 49 ++++++++++++++++-------------- server/autocomplete.go | 69 +++++++++++++++++++----------------------- server/budget.go | 10 +++--- server/budgeting.go | 33 +++++++++----------- server/category.go | 14 ++++----- server/http.go | 8 ----- server/reconcile.go | 44 +++++++++++---------------- server/transaction.go | 43 +++++++++++++------------- server/ynab-import.go | 50 +++++++++++++++--------------- 10 files changed, 168 insertions(+), 199 deletions(-) diff --git a/server/account.go b/server/account.go index 6de2af0..1bae15f 100644 --- a/server/account.go +++ b/server/account.go @@ -5,7 +5,6 @@ import ( "time" "git.javil.eu/jacob1123/budgeteer/postgres" - "github.com/gin-gonic/gin" "github.com/google/uuid" "github.com/labstack/echo/v4" ) @@ -18,19 +17,17 @@ type FilterTransactionsRequest struct { ToDate time.Time `json:"to_date"` } -func (h *Handler) filteredTransactions(c *echo.Context) { +func (h *Handler) filteredTransactions(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } var request FilterTransactionsRequest - err = c.BindJSON(&request) + err = c.Bind(&request) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } params := postgres.GetFilteredTransactionsParams{ @@ -43,13 +40,12 @@ func (h *Handler) filteredTransactions(c *echo.Context) { params.AccountID, params.FilterAccount = accountID.UUID, filterAccount params.PayeeID, params.FilterPayee = parseEmptyUUID(request.PayeeID) - transactions, err := h.Service.GetFilteredTransactions(c.Request.Context(), params) + transactions, err := h.Service.GetFilteredTransactions(c.Request().Context(), params) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return echo.NewHTTPError(http.StatusInternalServerError, err) } - c.JSON(http.StatusOK, TransactionsResponse{nil, transactions}) + return c.JSON(http.StatusOK, TransactionsResponse{nil, transactions}) } func parseEmptyUUID(value string) (uuid.NullUUID, bool) { @@ -65,21 +61,19 @@ func parseEmptyUUID(value string) (uuid.NullUUID, bool) { return uuid.NullUUID{val, true}, true } -func (h *Handler) problematicTransactions(c *gin.Context) { +func (h *Handler) problematicTransactions(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } - transactions, err := h.Service.GetProblematicTransactions(c.Request.Context(), budgetUUID) + transactions, err := h.Service.GetProblematicTransactions(c.Request().Context(), budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return err } - c.JSON(http.StatusOK, TransactionsResponse{nil, transactions}) + return c.JSON(http.StatusOK, TransactionsResponse{nil, transactions}) } func (h *Handler) transactionsForAccount(c echo.Context) error { @@ -113,19 +107,17 @@ type EditAccountRequest struct { IsOpen bool `json:"isOpen"` } -func (h *Handler) editAccount(c *gin.Context) { +func (h *Handler) editAccount(c echo.Context) error { accountID := c.Param("accountid") accountUUID, err := uuid.Parse(accountID) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } var request EditAccountRequest - err = c.BindJSON(&request) + err = c.Bind(&request) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } updateParams := postgres.UpdateAccountParams{ @@ -134,11 +126,10 @@ func (h *Handler) editAccount(c *gin.Context) { IsOpen: request.IsOpen, ID: accountUUID, } - account, err := h.Service.UpdateAccount(c.Request.Context(), updateParams) + account, err := h.Service.UpdateAccount(c.Request().Context(), updateParams) if err != nil { - c.AbortWithError(http.StatusNotFound, err) - return + return echo.NewHTTPError(http.StatusNotFound, err) } - h.getBudget(c, account.BudgetID) + return h.getBudget(c, account.BudgetID) } diff --git a/server/admin.go b/server/admin.go index b3a5b81..53a2826 100644 --- a/server/admin.go +++ b/server/admin.go @@ -4,63 +4,66 @@ import ( "fmt" "net/http" - "github.com/gin-gonic/gin" "github.com/google/uuid" + "github.com/labstack/echo/v4" "github.com/pressly/goose/v3" ) -func (h *Handler) clearDatabase(c *gin.Context) { +func (h *Handler) clearDatabase(c echo.Context) error { if err := goose.Reset(h.Service.DB, "schema"); err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) } if err := goose.Up(h.Service.DB, "schema"); err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) } + + return nil } -func (h *Handler) deleteBudget(c *gin.Context) { +func (h *Handler) deleteBudget(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithStatus(http.StatusBadRequest) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } - h.clearBudgetData(c, budgetUUID) - - err = h.Service.DeleteBudget(c.Request.Context(), budgetUUID) + err = h.clearBudgetData(c, budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return err } + + err = h.Service.DeleteBudget(c.Request().Context(), budgetUUID) + if err != nil { + return err + } + + return nil } -func (h *Handler) clearBudgetData(c *gin.Context, budgetUUID uuid.UUID) { - rows, err := h.Service.DeleteAllAssignments(c.Request.Context(), budgetUUID) +func (h *Handler) clearBudgetData(c echo.Context, budgetUUID uuid.UUID) error { + rows, err := h.Service.DeleteAllAssignments(c.Request().Context(), budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return err } fmt.Printf("Deleted %d assignments\n", rows) - rows, err = h.Service.DeleteAllTransactions(c.Request.Context(), budgetUUID) + rows, err = h.Service.DeleteAllTransactions(c.Request().Context(), budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return err } fmt.Printf("Deleted %d transactions\n", rows) + return nil } -func (h *Handler) clearBudget(c *gin.Context) { +func (h *Handler) clearBudget(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithStatus(http.StatusBadRequest) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } - h.clearBudgetData(c, budgetUUID) + return h.clearBudgetData(c, budgetUUID) } diff --git a/server/autocomplete.go b/server/autocomplete.go index 9d88c70..1360513 100644 --- a/server/autocomplete.go +++ b/server/autocomplete.go @@ -5,63 +5,58 @@ import ( "strings" "git.javil.eu/jacob1123/budgeteer/postgres" - "github.com/gin-gonic/gin" "github.com/google/uuid" + "github.com/labstack/echo/v4" ) -func (h *Handler) autocompleteAccounts(c *gin.Context) { +func (h *Handler) autocompleteAccounts(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"budgetid missing from URL"}) - return + return echo.NewHTTPError(http.StatusBadRequest, "budgetid missing from URL") } - query := c.Request.URL.Query().Get("s") + query := c.Request().URL.Query().Get("s") searchParams := postgres.SearchAccountsParams{ BudgetID: budgetUUID, Search: "%" + query + "%", } - categories, err := h.Service.SearchAccounts(c.Request.Context(), searchParams) + categories, err := h.Service.SearchAccounts(c.Request().Context(), searchParams) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return err } - c.JSON(http.StatusOK, categories) + return c.JSON(http.StatusOK, categories) } -func (h *Handler) autocompleteCategories(c *gin.Context) { +func (h *Handler) autocompleteCategories(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"budgetid missing from URL"}) - return + return echo.NewHTTPError(http.StatusBadRequest, "budgetid missing from URL") } - query := c.Request.URL.Query().Get("s") + query := c.Request().URL.Query().Get("s") searchParams := postgres.SearchCategoriesParams{ BudgetID: budgetUUID, Search: "%" + query + "%", } - categories, err := h.Service.SearchCategories(c.Request.Context(), searchParams) + categories, err := h.Service.SearchCategories(c.Request().Context(), searchParams) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return echo.NewHTTPError(http.StatusInternalServerError, err) } - c.JSON(http.StatusOK, categories) + return c.JSON(http.StatusOK, categories) } -func (h *Handler) autocompletePayee(c *gin.Context) { +func (h *Handler) autocompletePayee(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"budgetid missing from URL"}) - return + return echo.NewHTTPError(http.StatusBadRequest, "budgetid missing from URL") } - query := c.Request.URL.Query().Get("s") + query := c.Request().URL.Query().Get("s") transferPrefix := "Transfer" if strings.HasPrefix(query, transferPrefix) { @@ -70,25 +65,23 @@ func (h *Handler) autocompletePayee(c *gin.Context) { Search: "%" + strings.Trim(query[len(transferPrefix):], " \t\n:") + "%", } - accounts, err := h.Service.SearchAccounts(c.Request.Context(), searchParams) + accounts, err := h.Service.SearchAccounts(c.Request().Context(), searchParams) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return err } - c.JSON(http.StatusOK, accounts) - } else { - searchParams := postgres.SearchPayeesParams{ - BudgetID: budgetUUID, - Search: query + "%", - } - - payees, err := h.Service.SearchPayees(c.Request.Context(), searchParams) - if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return - } - - c.JSON(http.StatusOK, payees) + return c.JSON(http.StatusOK, accounts) } + + searchParams := postgres.SearchPayeesParams{ + BudgetID: budgetUUID, + Search: query + "%", + } + + payees, err := h.Service.SearchPayees(c.Request().Context(), searchParams) + if err != nil { + return err + } + + return c.JSON(http.StatusOK, payees) } diff --git a/server/budget.go b/server/budget.go index 682ac75..b64919a 100644 --- a/server/budget.go +++ b/server/budget.go @@ -3,17 +3,17 @@ package server import ( "net/http" - "github.com/gin-gonic/gin" + "github.com/labstack/echo/v4" ) type newBudgetInformation struct { Name string `json:"name"` } -func (h *Handler) newBudget(c *gin.Context) { +func (h *Handler) newBudget(c echo.Context) error { var newBudget newBudgetInformation if err := c.BindJSON(&newBudget); err != nil { - c.AbortWithError(http.StatusNotAcceptable, err) + return echo.NewHTTPError(http.StatusNotAcceptable, err) return } @@ -23,9 +23,9 @@ func (h *Handler) newBudget(c *gin.Context) { } userID := MustGetToken(c).GetID() - budget, err := h.Service.NewBudget(c.Request.Context(), newBudget.Name, userID) + budget, err := h.Service.NewBudget(c.Request().Context(), newBudget.Name, userID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } diff --git a/server/budgeting.go b/server/budgeting.go index 0527ce0..d99b744 100644 --- a/server/budgeting.go +++ b/server/budgeting.go @@ -7,8 +7,8 @@ import ( "git.javil.eu/jacob1123/budgeteer/postgres" "git.javil.eu/jacob1123/budgeteer/postgres/numeric" - "github.com/gin-gonic/gin" "github.com/google/uuid" + "github.com/labstack/echo/v4" ) type CategoryWithBalance struct { @@ -27,7 +27,7 @@ func NewCategoryWithBalance(category *postgres.GetCategoriesRow) CategoryWithBal } } -func (h *Handler) budgetingForMonth(c *gin.Context) { +func (h *Handler) budgetingForMonth(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { @@ -35,9 +35,9 @@ func (h *Handler) budgetingForMonth(c *gin.Context) { return } - budget, err := h.Service.GetBudget(c.Request.Context(), budgetUUID) + budget, err := h.Service.GetBudget(c.Request().Context(), budgetUUID) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) + return echo.NewHTTPError(http.StatusBadRequest, err) return } @@ -47,9 +47,9 @@ func (h *Handler) budgetingForMonth(c *gin.Context) { return } - data, err := h.getBudgetingViewForMonth(c.Request.Context(), budget, month) + data, err := h.getBudgetingViewForMonth(c.Request().Context(), budget, month) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } c.JSON(http.StatusOK, data) @@ -105,33 +105,30 @@ type BudgetingResponse struct { Budget postgres.Budget } -func (h *Handler) budget(c *gin.Context) { +func (h *Handler) budget(c echo.Context) error { budgetID := c.Param("budgetid") budgetUUID, err := uuid.Parse(budgetID) if err != nil { - c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"budgetid missing from URL"}) - return + return echo.NewHTTPError(http.StatusBadRequest, "budgetid missing from URL") } - h.getBudget(c, budgetUUID) + return h.getBudget(c, budgetUUID) } -func (h *Handler) getBudget(c *gin.Context, budgetUUID uuid.UUID) { - budget, err := h.Service.GetBudget(c.Request.Context(), budgetUUID) +func (h *Handler) getBudget(c echo.Context, budgetUUID uuid.UUID) error { + budget, err := h.Service.GetBudget(c.Request().Context(), budgetUUID) if err != nil { - c.AbortWithError(http.StatusNotFound, err) - return + return echo.NewHTTPError(http.StatusNotFound, err) } - accounts, err := h.Service.GetAccountsWithBalance(c.Request.Context(), budgetUUID) + accounts, err := h.Service.GetAccountsWithBalance(c.Request().Context(), budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) - return + return err } data := BudgetingResponse{accounts, budget} - c.JSON(http.StatusOK, data) + return c.JSON(http.StatusOK, data) } func (h *Handler) calculateBalances(budget postgres.Budget, month Month, diff --git a/server/category.go b/server/category.go index 7507cb7..fb43095 100644 --- a/server/category.go +++ b/server/category.go @@ -6,15 +6,15 @@ import ( "git.javil.eu/jacob1123/budgeteer/postgres" "git.javil.eu/jacob1123/budgeteer/postgres/numeric" - "github.com/gin-gonic/gin" "github.com/google/uuid" + "github.com/labstack/echo/v4" ) type SetCategoryAssignmentRequest struct { Assigned float64 } -func (h *Handler) setCategoryAssignment(c *gin.Context) { +func (h *Handler) setCategoryAssignment(c echo.Context) error { categoryID := c.Param("categoryid") categoryUUID, err := uuid.Parse(categoryID) if err != nil { @@ -25,20 +25,20 @@ func (h *Handler) setCategoryAssignment(c *gin.Context) { var request SetCategoryAssignmentRequest err = c.BindJSON(&request) if err != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("invalid payload: %w", err)) + return echo.NewHTTPError(http.StatusBadRequest, fmt.Errorf("invalid payload: %w", err)) return } date, err := getDate(c) if err != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("date invalid: %w", err)) + return echo.NewHTTPError(http.StatusBadRequest, fmt.Errorf("date invalid: %w", err)) return } var amount numeric.Numeric err = amount.Set(request.Assigned) if err != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("parse amount: %w", err)) + return echo.NewHTTPError(http.StatusBadRequest, fmt.Errorf("parse amount: %w", err)) return } @@ -47,9 +47,9 @@ func (h *Handler) setCategoryAssignment(c *gin.Context) { Date: date.FirstOfMonth(), Amount: amount, } - err = h.Service.UpdateAssignment(c.Request.Context(), updateArgs) + err = h.Service.UpdateAssignment(c.Request().Context(), updateArgs) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("update assignment: %w", err)) + return echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("update assignment: %w", err)) return } } diff --git a/server/http.go b/server/http.go index fdade1f..e6ddabe 100644 --- a/server/http.go +++ b/server/http.go @@ -33,14 +33,6 @@ func (h *Handler) Serve() { } } -type ErrorResponse struct { - Message string -} - -type SuccessResponse struct { - Message string -} - // LoadRoutes initializes all the routes. func (h *Handler) LoadRoutes(router *echo.Echo) { router.Use(enableCachingForStaticFiles()) diff --git a/server/reconcile.go b/server/reconcile.go index 2ac619b..80cb1ab 100644 --- a/server/reconcile.go +++ b/server/reconcile.go @@ -8,8 +8,8 @@ import ( "git.javil.eu/jacob1123/budgeteer/postgres" "git.javil.eu/jacob1123/budgeteer/postgres/numeric" - "github.com/gin-gonic/gin" "github.com/google/uuid" + "github.com/labstack/echo/v4" ) type ReconcileTransactionsRequest struct { @@ -22,68 +22,60 @@ type ReconcileTransactionsResponse struct { ReconciliationTransaction *postgres.DisplayTransaction } -func (h *Handler) reconcileTransactions(c *gin.Context) { +func (h *Handler) reconcileTransactions(c echo.Context) error { accountID := c.Param("accountid") accountUUID, err := uuid.Parse(accountID) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) - return + return echo.NewHTTPError(http.StatusBadRequest, err) } var request ReconcileTransactionsRequest - err = c.BindJSON(&request) + err = c.Bind(&request) if err != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("parse request: %w", err)) - return + return echo.NewHTTPError(http.StatusBadRequest, fmt.Errorf("parse request: %w", err)) } var amount numeric.Numeric err = amount.Set(request.ReconcilationTransactionAmount) if err != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("parse request: %w", err)) - return + return echo.NewHTTPError(http.StatusBadRequest, fmt.Errorf("parse request: %w", err)) } - tx, err := h.Service.BeginTx(c.Request.Context(), &sql.TxOptions{}) + tx, err := h.Service.BeginTx(c.Request().Context(), &sql.TxOptions{}) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("begin tx: %w", err)) - return + return fmt.Errorf("begin tx: %w", err) } db := h.Service.WithTx(tx) for _, transactionID := range request.TransactionIDs { - err := db.SetTransactionReconciled(c.Request.Context(), transactionID) + err := db.SetTransactionReconciled(c.Request().Context(), transactionID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("update transaction: %w", err)) - return + return fmt.Errorf("update transaction: %w", err) } } reconciliationTransaction, err := h.CreateReconcilationTransaction(amount, accountUUID, db, c) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("insert new transaction: %w", err)) - return + return fmt.Errorf("insert new transaction: %w", err) } - err = h.Service.SetLastReconciled(c.Request.Context(), accountUUID) + err = h.Service.SetLastReconciled(c.Request().Context(), accountUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("set last reconciled: %w", err)) - return + return fmt.Errorf("set last reconciled: %w", err) } err = tx.Commit() if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("commit: %w", err)) - return + return fmt.Errorf("commit: %w", err) } - c.JSON(http.StatusOK, ReconcileTransactionsResponse{ + return c.JSON(http.StatusOK, ReconcileTransactionsResponse{ Message: fmt.Sprintf("Set status for %d transactions", len(request.TransactionIDs)), ReconciliationTransaction: reconciliationTransaction, }) } -func (*Handler) CreateReconcilationTransaction(amount numeric.Numeric, accountUUID uuid.UUID, db *postgres.Queries, c *gin.Context) (*postgres.DisplayTransaction, error) { +func (*Handler) CreateReconcilationTransaction(amount numeric.Numeric, accountUUID uuid.UUID, db *postgres.Queries, c echo.Context) (*postgres.DisplayTransaction, error) { if amount.IsZero() { return nil, nil //nolint: nilnil } @@ -95,12 +87,12 @@ func (*Handler) CreateReconcilationTransaction(amount numeric.Numeric, accountUU AccountID: accountUUID, Status: "Reconciled", } - transactionUUID, err := db.CreateTransaction(c.Request.Context(), createTransaction) + transactionUUID, err := db.CreateTransaction(c.Request().Context(), createTransaction) if err != nil { return nil, fmt.Errorf("insert new transaction: %w", err) } - transaction, err := db.GetTransaction(c.Request.Context(), transactionUUID) + transaction, err := db.GetTransaction(c.Request().Context(), transactionUUID) if err != nil { return nil, fmt.Errorf("get created transaction: %w", err) } diff --git a/server/transaction.go b/server/transaction.go index 0a959ba..a98c2d6 100644 --- a/server/transaction.go +++ b/server/transaction.go @@ -10,6 +10,7 @@ import ( "git.javil.eu/jacob1123/budgeteer/postgres/numeric" "github.com/gin-gonic/gin" "github.com/google/uuid" + "github.com/labstack/echo/v4" ) type NewTransactionPayload struct { @@ -27,17 +28,17 @@ type NewTransactionPayload struct { State string `json:"state"` } -func (h *Handler) updateTransaction(c *gin.Context) { +func (h *Handler) updateTransaction(c echo.Context) error { var payload NewTransactionPayload err := c.BindJSON(&payload) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) + return echo.NewHTTPError(http.StatusBadRequest, err) return } amount, err := numeric.Parse(payload.Amount) if err != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("amount: %w", err)) + return echo.NewHTTPError(http.StatusBadRequest, fmt.Errorf("amount: %w", err)) return } @@ -51,17 +52,17 @@ func (h *Handler) updateTransaction(c *gin.Context) { h.UpdateTransaction(payload, amount, transactionUUID, c) } -func (h *Handler) newTransaction(c *gin.Context) { +func (h *Handler) newTransaction(c echo.Context) error { var payload NewTransactionPayload err := c.BindJSON(&payload) if err != nil { - c.AbortWithError(http.StatusBadRequest, err) + return echo.NewHTTPError(http.StatusBadRequest, err) return } amount, err := numeric.Parse(payload.Amount) if err != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("amount: %w", err)) + return echo.NewHTTPError(http.StatusBadRequest, fmt.Errorf("amount: %w", err)) return } @@ -77,39 +78,39 @@ func (h *Handler) newTransaction(c *gin.Context) { if payload.Payee.Type == "account" { groupID, err := h.CreateTransferForOtherAccount(newTransaction, amount, payload, c) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } newTransaction.GroupID = groupID } else { - payeeID, err := GetPayeeID(c.Request.Context(), payload, h) + payeeID, err := GetPayeeID(c.Request().Context(), payload, h) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("create payee: %w", err)) + return echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("create payee: %w", err)) } newTransaction.PayeeID = payeeID } - transactionUUID, err := h.Service.CreateTransaction(c.Request.Context(), newTransaction) + transactionUUID, err := h.Service.CreateTransaction(c.Request().Context(), newTransaction) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("create transaction: %w", err)) + return echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("create transaction: %w", err)) return } - transaction, err := h.Service.GetTransaction(c.Request.Context(), transactionUUID) + transaction, err := h.Service.GetTransaction(c.Request().Context(), transactionUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("get transaction: %w", err)) + return echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("get transaction: %w", err)) return } c.JSON(http.StatusOK, transaction) } -func (h *Handler) UpdateTransaction(payload NewTransactionPayload, amount numeric.Numeric, transactionUUID uuid.UUID, c *gin.Context) { +func (h *Handler) UpdateTransaction(payload NewTransactionPayload, amount numeric.Numeric, transactionUUID uuid.UUID, c echo.Context) error { if amount.IsZero() { - err := h.Service.DeleteTransaction(c.Request.Context(), transactionUUID) + err := h.Service.DeleteTransaction(c.Request().Context(), transactionUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("delete transaction: %w", err)) + return echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("delete transaction: %w", err)) } return } @@ -123,15 +124,15 @@ func (h *Handler) UpdateTransaction(payload NewTransactionPayload, amount numeri ID: transactionUUID, } - err := h.Service.UpdateTransaction(c.Request.Context(), editTransaction) + err := h.Service.UpdateTransaction(c.Request().Context(), editTransaction) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("edit transaction: %w", err)) + return echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("edit transaction: %w", err)) return } - transaction, err := h.Service.GetTransaction(c.Request.Context(), transactionUUID) + transaction, err := h.Service.GetTransaction(c.Request().Context(), transactionUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("get transaction: %w", err)) + return echo.NewHTTPError(http.StatusInternalServerError, fmt.Errorf("get transaction: %w", err)) return } @@ -146,7 +147,7 @@ func (h *Handler) CreateTransferForOtherAccount(newTransaction postgres.CreateTr // transfer does not need category. Either it's account is off-budget or no category was supplied. newTransaction.CategoryID = uuid.NullUUID{} - _, err := h.Service.CreateTransaction(c.Request.Context(), newTransaction) + _, err := h.Service.CreateTransaction(c.Request().Context(), newTransaction) if err != nil { return uuid.NullUUID{}, fmt.Errorf("create transfer transaction: %w", err) } diff --git a/server/ynab-import.go b/server/ynab-import.go index ac0da74..3fdacf7 100644 --- a/server/ynab-import.go +++ b/server/ynab-import.go @@ -4,11 +4,11 @@ import ( "net/http" "git.javil.eu/jacob1123/budgeteer/postgres" - "github.com/gin-gonic/gin" "github.com/google/uuid" + "github.com/labstack/echo/v4" ) -func (h *Handler) importYNAB(c *gin.Context) { +func (h *Handler) importYNAB(c echo.Context) error { budgetID, succ := c.Params.Get("budgetid") if !succ { c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"no budget_id specified"}) @@ -17,54 +17,54 @@ func (h *Handler) importYNAB(c *gin.Context) { budgetUUID, err := uuid.Parse(budgetID) if !succ { - c.AbortWithError(http.StatusBadRequest, err) + return echo.NewHTTPError(http.StatusBadRequest, err) return } - ynab, err := postgres.NewYNABImport(c.Request.Context(), h.Service.Queries, budgetUUID) + ynab, err := postgres.NewYNABImport(c.Request().Context(), h.Service.Queries, budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } transactionsFile, err := c.FormFile("transactions") if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } transactions, err := transactionsFile.Open() if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } - err = ynab.ImportTransactions(c.Request.Context(), transactions) + err = ynab.ImportTransactions(c.Request().Context(), transactions) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } assignmentsFile, err := c.FormFile("assignments") if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } assignments, err := assignmentsFile.Open() if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } - err = ynab.ImportAssignments(c.Request.Context(), assignments) + err = ynab.ImportAssignments(c.Request().Context(), assignments) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } } -func (h *Handler) exportYNABTransactions(c *gin.Context) { +func (h *Handler) exportYNABTransactions(c echo.Context) error { budgetID, succ := c.Params.Get("budgetid") if !succ { c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"no budget_id specified"}) @@ -73,24 +73,24 @@ func (h *Handler) exportYNABTransactions(c *gin.Context) { budgetUUID, err := uuid.Parse(budgetID) if !succ { - c.AbortWithError(http.StatusBadRequest, err) + return echo.NewHTTPError(http.StatusBadRequest, err) return } - ynab, err := postgres.NewYNABExport(c.Request.Context(), h.Service.Queries, budgetUUID) + ynab, err := postgres.NewYNABExport(c.Request().Context(), h.Service.Queries, budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } - err = ynab.ExportTransactions(c.Request.Context(), c.Writer) + err = ynab.ExportTransactions(c.Request().Context(), c.Writer) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } } -func (h *Handler) exportYNABAssignments(c *gin.Context) { +func (h *Handler) exportYNABAssignments(c echo.Context) error { budgetID, succ := c.Params.Get("budgetid") if !succ { c.AbortWithStatusJSON(http.StatusBadRequest, ErrorResponse{"no budget_id specified"}) @@ -99,19 +99,19 @@ func (h *Handler) exportYNABAssignments(c *gin.Context) { budgetUUID, err := uuid.Parse(budgetID) if !succ { - c.AbortWithError(http.StatusBadRequest, err) + return echo.NewHTTPError(http.StatusBadRequest, err) return } - ynab, err := postgres.NewYNABExport(c.Request.Context(), h.Service.Queries, budgetUUID) + ynab, err := postgres.NewYNABExport(c.Request().Context(), h.Service.Queries, budgetUUID) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } - err = ynab.ExportAssignments(c.Request.Context(), c.Writer) + err = ynab.ExportAssignments(c.Request().Context(), c.Writer) if err != nil { - c.AbortWithError(http.StatusInternalServerError, err) + return echo.NewHTTPError(http.StatusInternalServerError, err) return } }