chore: migrate to gitea

internal/account/database.go

@@ -1,11 +1,14 @@
 package account
 
 import (
-	"budget/internal/storage/dao"
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/utils"
+	"database/sql"
+	"errors"
 	"fmt"
 
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
+
 	"github.com/lib/pq"
 )
 
@@ -23,7 +26,12 @@ func (db *Database) GetAllAccountOfUser(id string) ([]*Account, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func(rows *sql.Rows) {
+		err := rows.Close()
+		if err != nil {
+			return
+		}
+	}(rows)
 
 	as := make([]*Account, 0)
 	for rows.Next() {
@@ -45,15 +53,22 @@ func (db *Database) GetAccountWithNameForUser(name string, id string) (*Account,
 		AND a.name = $2
 	`
 	row, err := db.Session.Query(q, id, name)
+	if err != nil {
+		return nil, err
+	}
 	if !row.Next() {
-		return nil, dao.NewDAOError(dao.ErrTypeNotFound, fmt.Errorf("No row found"))
+		return nil, dao.NewDAOError(dao.ErrTypeNotFound, fmt.Errorf("no row found"))
 	}
 	a := Account{}
-	row.Scan(&a.ID, &a.UserId, &a.Name, &a.Provider, &a.CreatedAt, &a.UpdatedAt)
+	err = row.Scan(&a.ID, &a.UserId, &a.Name, &a.Provider, &a.CreatedAt, &a.UpdatedAt)
+	if err != nil {
+		return nil, err
+	}
 	if row.Next() {
 		return nil, fmt.Errorf("Impossibru")
 	}
-	if errPq, ok := err.(*pq.Error); ok {
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
 		return nil, postgresql.HandlePgError(errPq)
 	}
 	if err != nil {

internal/account/handler.go

@@ -1,14 +1,15 @@
 package account
 
 import (
-	"budget/handler"
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/storage/model"
-	"budget/internal/storage/validators"
-	"budget/internal/user"
-	"budget/internal/utils"
 	"net/http"
 
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/handler"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/validators"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/user"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
+
 	"github.com/gin-gonic/gin"
 )
 
@@ -75,13 +76,15 @@ func (c *Context) CreateAccountOfUser(gc *gin.Context) {
 		return
 	}
 	utils.JSON(gc.Writer, http.StatusCreated, accountSaved)
-	return
 }
 
 func (c *Context) DeleteAccountOfUser(gc *gin.Context) {
 	userId := gc.Param("userId")
 	accountId := gc.Param("accountId")
-	c.service.DeleteAccountOfUser(userId, accountId)
+	err := c.service.DeleteAccountOfUser(userId, accountId)
+	if err != nil {
+		return
+	}
 
 }
 

internal/account/service.go

@@ -1,8 +1,8 @@
 package account
 
 import (
-	"budget/internal/storage/dao"
-	"budget/internal/storage/model"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
 )
 
 type Service struct {
@@ -12,8 +12,8 @@ type Service struct {
 func (s *Service) GetAllAccountOfUser(userId string) ([]*Account, error) {
 	accounts, err := s.db.GetAllAccountOfUser(userId)
 	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
+		switch e.Type {
+		case dao.ErrTypeNotFound:
 			return nil, &model.ErrNotFound
 		default:
 			return nil, &model.ErrInternalServer
@@ -31,8 +31,8 @@ func (s *Service) GetAllAccountOfUser(userId string) ([]*Account, error) {
 func (s *Service) GetAccountWithNameForUser(name string, id string) (*Account, error) {
 	account, err := s.db.GetAccountWithNameForUser(name, id)
 	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
+		switch e.Type {
+		case dao.ErrTypeNotFound:
 			return nil, &model.ErrNotFound
 		default:
 			return nil, &model.ErrInternalServer

internal/expense/database.go

@@ -1,8 +1,10 @@
 package expense
 
 import (
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/utils"
+	"database/sql"
+
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
 
 	"github.com/lib/pq"
 )
@@ -43,7 +45,12 @@ func (db Database) GetExpensesOfAnAccountBetween(id, from, to string) ([]*Expens
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func(rows *sql.Rows) {
+		err := rows.Close()
+		if err != nil {
+			return
+		}
+	}(rows)
 
 	es := make([]*Expense, 0)
 	for rows.Next() {
@@ -67,7 +74,12 @@ func (db Database) GetAllExpensesOfAnAccount(id string) ([]*Expense, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func(rows *sql.Rows) {
+		err := rows.Close()
+		if err != nil {
+			return
+		}
+	}(rows)
 
 	es := make([]*Expense, 0)
 	for rows.Next() {

internal/expense/handler.go

@@ -1,16 +1,17 @@
 package expense
 
 import (
-	"budget/handler"
-	"budget/internal/account"
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/storage/model"
-	"budget/internal/storage/validators"
-	"budget/internal/utils"
 	"encoding/csv"
 	"net/http"
 	"time"
 
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/handler"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/account"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/validators"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
+
 	"github.com/gin-gonic/gin"
 )
 
@@ -42,7 +43,7 @@ func (c *Context) CreateAnExpense(gc *gin.Context) {
 		csvr := csv.NewReader(csvFile)
 		csvr.FieldsPerRecord = -1
 		csvr.Comma = ';'
-		filedata, err := csvr.ReadAll()
+		filedata, _ := csvr.ReadAll()
 
 		account, err := c.accountService.GetASpecificAccountForUser(userId, accountID)
 		if err != nil {

internal/expense/service.go

@@ -1,13 +1,14 @@
 package expense
 
 import (
-	"budget/internal/account"
-	"budget/internal/storage/dao"
-	"budget/internal/storage/model"
-	"budget/internal/utils"
 	"strconv"
 	"strings"
 	"time"
+
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/account"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
 )
 
 type Service struct {
@@ -18,8 +19,8 @@ func (s Service) GetExpensesOfAnAccountBetween(accountId, from, to string) ([]*E
 	expenses, err := s.db.GetExpensesOfAnAccountBetween(accountId, from, to)
 	utils.GetLogger().Info(err)
 	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
+		switch e.Type {
+		case dao.ErrTypeNotFound:
 			return nil, &model.ErrNotFound
 		default:
 			return nil, &model.ErrInternalServer
@@ -38,8 +39,8 @@ func (s Service) GetAllExpensesOfAnAccount(accountId string) ([]*Expense, error)
 	expenses, err := s.db.GetAllExpensesOfAnAccount(accountId)
 	utils.GetLogger().Info(err)
 	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
+		switch e.Type {
+		case dao.ErrTypeNotFound:
 			return nil, &model.ErrNotFound
 		default:
 			return nil, &model.ErrInternalServer
@@ -100,7 +101,10 @@ func (s Service) processCaisseEpargne(filedata [][]string, account *account.Acco
 			},
 			AccountId: account.ID,
 		}
-		s.CreateExpense(expense)
+		err = s.CreateExpense(expense)
+		if err != nil {
+			return err
+		}
 		utils.GetLogger().Info(val)
 	}
 

internal/jointaccount/database.go

@@ -1,116 +0,0 @@
-package jointaccount
-
-import (
-	"budget/internal/storage/dao"
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/utils"
-	"fmt"
-
-	"github.com/lib/pq"
-)
-
-type Database struct {
-	*postgresql.DatabasePostgreSQL
-}
-
-func (db *Database) GetAllJointaccountOfUser(id string) ([]*Jointaccount, error) {
-	q := `
-		SELECT a.id, a.user_id, a.name, a.provider, a.created_at, a.updated_at
-		FROM public.jointaccount a
-		WHERE a.user_id = $1
-	`
-	rows, err := db.Session.Query(q, id)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	as := make([]*Jointaccount, 0)
-	for rows.Next() {
-		a := Jointaccount{}
-		err := rows.Scan(&a.ID, &a.UserId, &a.Name, &a.Provider, &a.CreatedAt, &a.UpdatedAt)
-		if err != nil {
-			return nil, err
-		}
-		as = append(as, &a)
-	}
-	return as, nil
-}
-
-func (db *Database) GetJointaccountWithNameForUser(name string, id string) (*Jointaccount, error) {
-	q := `
-		SELECT a.id, a.user_id, a.name, a.provider, a.created_at, a.updated_at
-		FROM public.jointaccount a
-		WHERE a.user_id = $1
-		AND a.name = $2
-	`
-	row, err := db.Session.Query(q, id, name)
-	if !row.Next() {
-		return nil, dao.NewDAOError(dao.ErrTypeNotFound, fmt.Errorf("No row found"))
-	}
-	a := Jointaccount{}
-	row.Scan(&a.ID, &a.UserId, &a.Name, &a.Provider, &a.CreatedAt, &a.UpdatedAt)
-	if row.Next() {
-		return nil, fmt.Errorf("Impossibru")
-	}
-	if errPq, ok := err.(*pq.Error); ok {
-		return nil, postgresql.HandlePgError(errPq)
-	}
-	if err != nil {
-		utils.GetLogger().Info(err)
-		return nil, err
-	}
-	return &a, nil
-}
-
-func (db *Database) CreateJointaccount(jointaccount *Jointaccount) error {
-	q := `
-		INSERT INTO public.jointaccount
-			(Name, Provider, user_id)
-		VALUES
-			($1, $2, $3)
-		RETURNING id, created_at
-	`
-
-	err := db.Session.
-		QueryRow(q, jointaccount.Name, jointaccount.Provider, jointaccount.UserId).
-		Scan(&jointaccount.ID, &jointaccount.CreatedAt)
-	if errPq, ok := err.(*pq.Error); ok {
-		return postgresql.HandlePgError(errPq)
-	}
-	return err
-
-}
-
-func (db *Database) DeleteJointaccountOfAnUser(userId, jointaccountId string) error {
-	query := `
-		DELETE FROM jointaccount
-		WHERE user_id = $1
-		AND id = $2;`
-	_, err := db.Session.Exec(query, userId, jointaccountId)
-	return err
-}
-
-func (db *Database) GetASpecificJointaccountForUser(userId, jointaccountId string) (*Jointaccount, error) {
-	q := `
-		SELECT a.id, a.user_id, a.name, a.provider, a.created_at, a.updated_at
-		FROM public.jointaccount a
-		WHERE a.user_id = $1
-		AND a.id = $2
-	`
-	row := db.Session.QueryRow(q, userId, jointaccountId)
-	a := Jointaccount{}
-	err := row.Scan(&a.ID, &a.UserId, &a.Name, &a.Provider, &a.CreatedAt, &a.UpdatedAt)
-	if errPq, ok := err.(*pq.Error); ok {
-		return nil, postgresql.HandlePgError(errPq)
-	}
-	if err != nil {
-		utils.GetLogger().Info(err)
-		return nil, err
-	}
-	return &a, nil
-}
-
-func NewDatabase(db *postgresql.DatabasePostgreSQL) *Database {
-	return &Database{db}
-}

internal/jointaccount/handler.go

@@ -1,100 +0,0 @@
-package jointaccount
-
-import (
-	"budget/handler"
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/storage/model"
-	"budget/internal/storage/validators"
-	"budget/internal/user"
-	"budget/internal/utils"
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-type Context struct {
-	service     *Service
-	db          *Database
-	userService *user.Service
-	*handler.Context
-}
-
-func (c *Context) GetAllJointaccountOfUser(gc *gin.Context) {
-	userId := gc.Param("userId")
-	jointaccounts, err := c.service.GetAllJointaccountOfUser(userId)
-	if e, ok := err.(*model.APIError); ok {
-		utils.GetLoggerFromCtx(gc).WithError(err).WithField("type", e.Type).Error("error GetAllJointaccounts: get jointaccounts")
-		utils.JSONErrorWithMessage(gc.Writer, *e, e.Description)
-	} else if err != nil {
-		utils.GetLoggerFromCtx(gc).WithError(err).Error("error while get jointaccounts")
-		utils.JSONError(gc.Writer, model.ErrInternalServer)
-		return
-	}
-
-	if len(jointaccounts) == 0 {
-		utils.JSON(gc.Writer, http.StatusNoContent, nil)
-	} else {
-		utils.JSON(gc.Writer, http.StatusOK, jointaccounts)
-	}
-
-}
-
-func (c *Context) CreateJointaccountOfUser(gc *gin.Context) {
-	userId := gc.Param("userId")
-
-	var jointaccount Jointaccount
-	var jointaccountEditable JointaccountEditable
-	if err := gc.BindJSON(&jointaccountEditable); err != nil {
-		utils.JSONError(gc.Writer, validators.NewDataValidationAPIError(err))
-		return
-	}
-	jointaccount = Jointaccount{JointaccountEditable: jointaccountEditable, UserId: userId}
-	jointaccountFound, err := c.service.GetJointaccountWithNameForUser(jointaccount.Name, userId)
-	if e, ok := err.(*model.APIError); ok {
-		if e.Type != model.ErrNotFound.Type {
-			utils.GetLoggerFromCtx(gc).WithError(err).WithField("type", e.Type).Error("error GetJointaccount: get jointaccount error")
-			utils.JSONErrorWithMessage(gc.Writer, *e, e.Description)
-			return
-		}
-	} else if err != nil {
-		utils.GetLoggerFromCtx(gc).WithError(err).Error("error while get jointaccount")
-		utils.JSONError(gc.Writer, model.ErrInternalServer)
-		return
-	}
-
-	if jointaccountFound != nil {
-		utils.GetLoggerFromCtx(gc).WithError(&model.ErrAlreadyExists).WithField("type", model.ErrAlreadyExists.Type).Error("error CreateJointaccount: jointaccount already exists")
-		utils.JSONErrorWithMessage(gc.Writer, model.ErrAlreadyExists, "jointaccount already exists with the same Name")
-		return
-	}
-	jointaccount.UserId = userId
-	jointaccountSaved, err := c.service.CreateJointaccount(jointaccount)
-	if err != nil {
-		utils.GetLogger().Info(err)
-		utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
-		return
-	}
-	utils.JSON(gc.Writer, http.StatusCreated, jointaccountSaved)
-	return
-}
-
-func (c *Context) DeleteJointaccountOfUser(gc *gin.Context) {
-	userId := gc.Param("userId")
-	jointaccountId := gc.Param("jointaccountId")
-	c.service.DeleteJointaccountOfUser(userId, jointaccountId)
-
-}
-
-func (c *Context) GetSpecificJointaccountOfUser(gc *gin.Context) {
-	userId := gc.Param("userId")
-	jointaccountId := gc.Param("jointaccountId")
-	jointaccount, _ := c.service.GetASpecificJointaccountForUser(userId, jointaccountId)
-	utils.JSON(gc.Writer, http.StatusOK, jointaccount)
-}
-
-func NewHandler(ctx *handler.Context, db *postgresql.DatabasePostgreSQL) *Context {
-	database := NewDatabase(db)
-	service := NewService(database)
-	userService := user.NewService(user.NewDatabase(db))
-	return &Context{service: service, db: database, userService: userService, Context: ctx}
-}

internal/jointaccount/model.go

@@ -1,16 +0,0 @@
-package jointaccount
-
-import "time"
-
-type Jointaccount struct {
-	JointaccountEditable
-	UserId string `json:"userId,omitempty"`
-}
-
-type JointaccountEditable struct {
-	ID        string     `json:"id,omitempty"`
-	Name      string     `json:"name"`
-	Provider  string     `json:"provider"`
-	CreatedAt time.Time  `json:"createdAt,omitempty"`
-	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
-}

internal/jointaccount/service.go

@@ -1,62 +0,0 @@
-package jointaccount
-
-import (
-	"budget/internal/storage/dao"
-	"budget/internal/storage/model"
-)
-
-type Service struct {
-	db *Database
-}
-
-func (s *Service) GetAllJointaccountOfUser(userId string) ([]*Jointaccount, error) {
-	jointaccounts, err := s.db.GetAllJointaccountOfUser(userId)
-	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
-			return nil, &model.ErrNotFound
-		default:
-			return nil, &model.ErrInternalServer
-		}
-	} else if err != nil {
-		return nil, &model.ErrInternalServer
-	}
-
-	if jointaccounts == nil {
-		return nil, &model.ErrNotFound
-	}
-	return jointaccounts, nil
-}
-
-func (s *Service) GetJointaccountWithNameForUser(name string, id string) (*Jointaccount, error) {
-	jointaccount, err := s.db.GetJointaccountWithNameForUser(name, id)
-	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
-			return nil, &model.ErrNotFound
-		default:
-			return nil, &model.ErrInternalServer
-		}
-	} else if err != nil {
-		return nil, &model.ErrInternalServer
-	}
-	return jointaccount, nil
-}
-
-func (s *Service) CreateJointaccount(jointaccount Jointaccount) (*Jointaccount, error) {
-	err := s.db.CreateJointaccount(&jointaccount)
-	return &jointaccount, err
-}
-
-func (s *Service) DeleteJointaccountOfUser(userId, jointaccountId string) error {
-	return s.db.DeleteJointaccountOfAnUser(userId, jointaccountId)
-}
-
-func (s *Service) GetASpecificJointaccountForUser(userId, jointaccountId string) (*Jointaccount, error) {
-	return s.db.GetASpecificJointaccountForUser(userId, jointaccountId)
-
-}
-
-func NewService(database *Database) *Service {
-	return &Service{db: database}
-}

internal/jointexpense/database.go

@@ -1,86 +0,0 @@
-package jointexpense
-
-import (
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/utils"
-
-	"github.com/lib/pq"
-)
-
-type Database struct {
-	*postgresql.DatabasePostgreSQL
-}
-
-func (db *Database) CreateJointexpense(jointexpense *Jointexpense) error {
-	q := `
-		INSERT INTO public.jointexpense
-			(jointaccount_id, value, type_jointexpense, jointexpense_date, libelle)
-		VALUES
-			($1, $2, $3, $4, $5)
-		RETURNING id, created_at
-	`
-
-	err := db.Session.
-		QueryRow(q, jointexpense.JointaccountId, jointexpense.Value, jointexpense.TypeJointexpense, jointexpense.JointexpenseDate, jointexpense.Libelle).
-		Scan(&jointexpense.ID, &jointexpense.CreatedAt)
-	if err != nil {
-		utils.GetLogger().Info(err)
-	}
-	if errPq, ok := err.(*pq.Error); ok {
-		return postgresql.HandlePgError(errPq)
-	}
-	return err
-}
-
-func (db Database) GetJointexpensesOfAnJointaccountBetween(id, from, to string) ([]*Jointexpense, error) {
-	q := `
-		SELECT a.id, a.jointaccount_id, a.value, a.type_jointexpense, a.jointexpense_date, a.created_at, a.updated_at, a.libelle
-		FROM public.jointexpense a
-		WHERE a.jointaccount_id = $1
-		AND a.jointexpense_date BETWEEN $2 and $3
-	`
-	rows, err := db.Session.Query(q, id, from, to)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	es := make([]*Jointexpense, 0)
-	for rows.Next() {
-		e := Jointexpense{}
-		err := rows.Scan(&e.ID, &e.JointjointaccountId, &e.Value, &e.TypeJointexpense, &e.JointexpenseDate, &e.CreatedAt, &e.UpdatedAt, &e.Libelle)
-		if err != nil {
-			return nil, err
-		}
-		es = append(es, &e)
-	}
-	return es, nil
-}
-
-func (db Database) GetAllJointexpensesOfAnJointaccount(id string) ([]*Jointexpense, error) {
-	q := `
-		SELECT a.id, a.jointaccount_id, a.value, a.type_jointexpense, a.jointexpense_date, a.created_at, a.updated_at, a.libelle
-		FROM public.jointexpense a
-		WHERE a.jointaccount_id = $1
-	`
-	rows, err := db.Session.Query(q, id)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	es := make([]*Jointexpense, 0)
-	for rows.Next() {
-		e := Jointexpense{}
-		err := rows.Scan(&e.ID, &e.JointaccountId, &e.Value, &e.TypeJointexpense, &e.JointexpenseDate, &e.CreatedAt, &e.UpdatedAt, &e.Libelle)
-		if err != nil {
-			return nil, err
-		}
-		es = append(es, &e)
-	}
-	return es, nil
-}
-
-func NewDatabase(db *postgresql.DatabasePostgreSQL) *Database {
-	return &Database{db}
-}

internal/jointexpense/handler.go

@@ -1,132 +0,0 @@
-package jointexpense
-
-import (
-	"budget/handler"
-	"budget/internal/jointaccount"
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/storage/model"
-	"budget/internal/storage/validators"
-	"budget/internal/utils"
-	"encoding/csv"
-	"net/http"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-type Context struct {
-	service             *Service
-	db                  *Database
-	jointaccountService *jointaccount.Service
-	*handler.Context
-}
-
-func (c *Context) ImportJointexpenseFromCSV(gc *gin.Context) {
-}
-func (c *Context) CreateAnJointexpense(gc *gin.Context) {
-	jointaccountID := gc.Param("jointaccountId")
-	userId := gc.Param("userId")
-	csvHeaderFile, err := gc.FormFile("attachment")
-	if err != nil {
-		utils.GetLogger().Info(err)
-		utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
-		return
-	}
-	if err == nil {
-		csvFile, err := csvHeaderFile.Open()
-		if err != nil {
-			utils.GetLogger().Info(err)
-			utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
-			return
-		}
-		csvr := csv.NewReader(csvFile)
-		csvr.FieldsPerRecord = -1
-		csvr.Comma = ';'
-		filedata, err := csvr.ReadAll()
-
-		jointaccount, err := c.jointaccountService.GetASpecificJointaccountForUser(userId, jointaccountID)
-		if err != nil {
-			utils.GetLogger().Info(err)
-			utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
-			return
-		}
-		err = c.service.ProcessCSVFile(filedata, jointaccount)
-		if err != nil {
-			utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
-			return
-		}
-		return
-	}
-	var jointexpense Jointexpense
-	var jointexpenseEditable JointexpenseEditable
-	if err := gc.BindJSON(&jointexpenseEditable); err != nil {
-		utils.JSONError(gc.Writer, validators.NewDataValidationAPIError(err))
-		return
-	}
-	jointexpense = Jointexpense{JointexpenseEditable: jointexpenseEditable, JointaccountId: jointaccountID}
-	err = c.service.CreateJointexpense(&jointexpense)
-	if err != nil {
-		utils.GetLogger().Info(err)
-		utils.JSONErrorWithMessage(gc.Writer, model.ErrInternalServer, err.Error())
-		return
-	}
-	utils.JSON(gc.Writer, http.StatusCreated, jointexpense)
-}
-
-func (c *Context) DeleteJointexpense(gc *gin.Context) {
-
-}
-
-func (c *Context) GetAllJointexpenses(gc *gin.Context) {
-	jointaccountId := gc.Param("jointaccountId")
-	from := gc.Query("from")
-	to := gc.Query("to")
-	var jointexpenses []*Jointexpense
-	var err error
-	if from != "" || to != "" {
-		if to == "" {
-			fromParsed, err := time.Parse("2006-01-02", from)
-			if err == nil {
-				to = time.Now().Format("2006-01-02")
-			} else {
-				to = fromParsed.AddDate(0, 1, 0).Format("2006-01-02")
-			}
-		}
-		if from == "" {
-			toParsed, err := time.Parse("2006-01-02", to)
-			if err == nil {
-				from = "1900-01-01"
-			} else {
-				from = toParsed.AddDate(0, -1, 0).Format("2006-01-02")
-			}
-		}
-		jointexpenses, err = c.service.GetJointexpensesOfAnJointaccountBetween(jointaccountId, from, to)
-	} else {
-		jointexpenses, err = c.service.GetAllJointexpensesOfAnJointaccount(jointaccountId)
-	}
-	if e, ok := err.(*model.APIError); ok {
-		utils.GetLoggerFromCtx(gc).WithError(err).WithField("type", e.Type).Error("error GetAllJointexpenses: get jointexpenses")
-		utils.JSONErrorWithMessage(gc.Writer, *e, e.Description)
-	} else if err != nil {
-		utils.GetLoggerFromCtx(gc).WithError(err).Error("error while get jointexpenses")
-		utils.JSONError(gc.Writer, model.ErrInternalServer)
-		return
-	}
-
-	if len(jointexpenses) == 0 {
-		utils.JSON(gc.Writer, http.StatusNoContent, nil)
-	} else {
-		utils.JSON(gc.Writer, http.StatusOK, jointexpenses)
-	}
-}
-
-func (c *Context) GetAnJointexpenses(context *gin.Context) {
-
-}
-
-func NewHandler(ctx *handler.Context, db *postgresql.DatabasePostgreSQL) *Context {
-	database := NewDatabase(db)
-	service := NewService(database)
-	jointaccountService := jointaccount.NewService(jointaccount.NewDatabase(db))
-	return &Context{service: service, db: database, jointaccountService: jointaccountService, Context: ctx}
-}

internal/jointexpense/model.go

@@ -1,18 +0,0 @@
-package jointexpense
-
-import "time"
-
-type Jointexpense struct {
-	JointexpenseEditable
-	JointaccountId string `json:"jointaccountId,omitempty"`
-}
-
-type JointexpenseEditable struct {
-	ID               string     `json:"id,omitempty"`
-	Value            float32    `json:"value"`
-	Libelle          string     `json:"libelle"`
-	TypeJointexpense string     `json:"typeJointexpense"`
-	JointexpenseDate time.Time  `json:"jointexpenseDate,omitempty"`
-	CreatedAt        *time.Time `json:"createdAt,omitempty"`
-	UpdatedAt        *time.Time `json:"updatedAt,omitempty"`
-}

internal/jointexpense/service.go

@@ -1,120 +0,0 @@
-package jointexpense
-
-import (
-	"budget/internal/jointaccount"
-	"budget/internal/storage/dao"
-	"budget/internal/storage/model"
-	"budget/internal/utils"
-	"strconv"
-	"strings"
-	"time"
-)
-
-type Service struct {
-	db *Database
-}
-
-func (s Service) GetJointexpensesOfAnJointaccountBetween(jointaccountId, from, to string) ([]*Jointexpense, error) {
-	jointexpenses, err := s.db.GetJointexpensesOfAnJointaccountBetween(jointaccountId, from, to)
-	utils.GetLogger().Info(err)
-	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
-			return nil, &model.ErrNotFound
-		default:
-			return nil, &model.ErrInternalServer
-		}
-	} else if err != nil {
-		return nil, &model.ErrInternalServer
-	}
-
-	if jointexpenses == nil {
-		return nil, &model.ErrNotFound
-	}
-	return jointexpenses, nil
-}
-
-func (s Service) GetAllJointexpensesOfAnJointaccount(jointaccountId string) ([]*Jointexpense, error) {
-	jointexpenses, err := s.db.GetAllJointexpensesOfAnJointaccount(jointaccountId)
-	utils.GetLogger().Info(err)
-	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
-			return nil, &model.ErrNotFound
-		default:
-			return nil, &model.ErrInternalServer
-		}
-	} else if err != nil {
-		return nil, &model.ErrInternalServer
-	}
-
-	if jointexpenses == nil {
-		return nil, &model.ErrNotFound
-	}
-	return jointexpenses, nil
-}
-
-func (s Service) CreateJointexpense(jointexpense *Jointexpense) error {
-
-	return s.db.CreateJointexpense(jointexpense)
-}
-
-func (s Service) ProcessCSVFile(filedata [][]string, jointaccount *jointaccount.Jointaccount) error {
-	switch jointaccount.Provider {
-	case "caisse-epargne":
-		return s.processCaisseEpargne(filedata, jointaccount)
-	case "boursorama":
-		return s.processBoursorama(filedata, jointaccount)
-	case "bnp":
-		return s.processBnp(filedata, jointaccount)
-	default:
-		return nil
-	}
-
-}
-
-func (s Service) processCaisseEpargne(filedata [][]string, jointaccount *jointaccount.Jointaccount) error {
-	for _, val := range filedata[4:] {
-		jointexpenseDate, err := time.Parse("02/01/06", val[0])
-		if err != nil {
-			utils.GetLogger().Info(err)
-			continue
-		}
-		amount := val[3]
-		typeJointexpense := "D"
-		if amount == "" {
-			amount = val[4]
-			typeJointexpense = "C"
-		}
-		amountParsed, err := strconv.ParseFloat(strings.Trim(strings.ReplaceAll(amount, ",", "."), "+"), 32)
-		if err != nil {
-			utils.GetLogger().Info(err)
-			continue
-		}
-		jointexpense := &Jointexpense{
-			JointexpenseEditable: JointexpenseEditable{
-				Value:            float32(amountParsed),
-				Libelle:          val[2],
-				TypeJointexpense: typeJointexpense,
-				JointexpenseDate: jointexpenseDate,
-			},
-			JointaccountId: jointaccount.ID,
-		}
-		s.CreateJointexpense(jointexpense)
-		utils.GetLogger().Info(val)
-	}
-
-	return nil
-}
-
-func (s Service) processBoursorama(filedata [][]string, jointaccount *jointaccount.Jointaccount) error {
-	return nil
-}
-
-func (s Service) processBnp(filedata [][]string, jointaccount *jointaccount.Jointaccount) error {
-	return nil
-}
-
-func NewService(database *Database) *Service {
-	return &Service{db: database}
-}

internal/shared-account/database.go

@@ -1,6 +1,6 @@
 package sharedaccount
 
-import "budget/internal/storage/dao/postgresql"
+import "gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
 
 type Database struct {
 	*postgresql.DatabasePostgreSQL

internal/shared-account/handler.go

@@ -1,8 +1,8 @@
 package sharedaccount
 
 import (
-	"budget/handler"
-	"budget/internal/storage/dao/postgresql"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/handler"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
 
 	"github.com/gin-gonic/gin"
 )

internal/storage/dao/postgresql/database_postgresql.go

@@ -1,11 +1,12 @@
 package postgresql
 
 import (
-	"budget/internal/storage/dao"
-	"budget/internal/utils"
 	"database/sql"
 	"fmt"
 
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
+
 	"github.com/lib/pq"
 )
 

internal/storage/validators/error.go

@@ -1,12 +1,13 @@
 package validators
 
 import (
-	"budget/internal/storage/model"
-	"budget/internal/utils"
 	"fmt"
 	"regexp"
 	"strings"
 
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
+
 	"gopkg.in/go-playground/validator.v9"
 )
 

internal/user/database.go

@@ -1,10 +1,11 @@
 package user
 
 import (
-	"budget/internal/storage/dao"
-	"budget/internal/storage/dao/postgresql"
 	"database/sql"
 
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
+
 	"github.com/lib/pq"
 )
 
@@ -25,7 +26,12 @@ func (db *Database) GetAllUsers() ([]*User, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
+	defer func(rows *sql.Rows) {
+		err := rows.Close()
+		if err != nil {
+			return
+		}
+	}(rows)
 
 	us := make([]*User, 0)
 	for rows.Next() {

internal/user/handler.go

@@ -1,13 +1,14 @@
 package user
 
 import (
-	"budget/handler"
-	"budget/internal/storage/dao/postgresql"
-	"budget/internal/storage/model"
-	"budget/internal/utils"
 	"net/http"
 	"strings"
 
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/handler"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao/postgresql"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/utils"
+
 	"github.com/gin-gonic/gin"
 	"google.golang.org/api/oauth2/v2"
 )
@@ -42,7 +43,7 @@ func (hc *Context) ConnectUser(c *gin.Context) {
 		return
 	}
 
-	oauth2Service, err := oauth2.New(&http.Client{})
+	oauth2Service, err := oauth2.NewService(c)
 	if oauth2Service == nil {
 		utils.GetLoggerFromCtx(c).WithError(err).Error(err)
 		utils.JSONError(c.Writer, model.ErrInternalServer)
@@ -87,7 +88,7 @@ func (hc *Context) CreateUser(c *gin.Context) {
 		return
 	}
 
-	oauth2Service, err := oauth2.New(&http.Client{})
+	oauth2Service, err := oauth2.NewService(c)
 	if oauth2Service == nil {
 		utils.GetLogger().WithError(err).Error(err)
 		utils.JSONError(c.Writer, model.ErrInternalServer)

internal/user/service.go

@@ -1,8 +1,8 @@
 package user
 
 import (
-	"budget/internal/storage/dao"
-	"budget/internal/storage/model"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/dao"
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
 )
 
 type Service struct {
@@ -16,8 +16,8 @@ func NewService(database *Database) *Service {
 func (s *Service) GetUserById(userId string) (*User, error) {
 	user, err := s.db.GetUsersByID(userId)
 	if e, ok := err.(*dao.Error); ok {
-		switch {
-		case e.Type == dao.ErrTypeNotFound:
+		switch e.Type {
+		case dao.ErrTypeNotFound:
 			return nil, &model.ErrNotFound
 		default:
 			return nil, &model.ErrInternalServer

internal/utils/responses.go

@@ -1,16 +1,20 @@
 package utils
 
 import (
-	"budget/internal/storage/model"
 	"encoding/json"
 	"net/http"
+
+	"gitea.frenchtouch.duckdns.org/kratisto/budget-backend/internal/storage/model"
 )
 
 func JSON(w http.ResponseWriter, status int, data interface{}) {
 	w.Header().Set(HeaderNameContentType, HeaderValueApplicationJSONUTF8)
 	w.WriteHeader(status)
 	if data != nil {
-		json.NewEncoder(w).Encode(data)
+		err := json.NewEncoder(w).Encode(data)
+		if err != nil {
+			return
+		}
 	}
 }