Refactor entain test task (#1)

Author: Matrix278

.env.example

@@ -1,8 +1,8 @@
-POSTGRES_DB_HOST="localhost"
-POSTGRES_DB_PORT="5432"
-POSTGRES_DB_USER="user"
-POSTGRES_DB_PASS="12345"
-POSTGRES_DB_NAME="entain"
-POSTGRES_DATABASEURL="postgres://${POSTGRES_DB_USER}:${POSTGRES_DB_PASS}@${POSTGRES_DB_HOST}:${POSTGRES_DB_PORT}/${POSTGRES_DB_NAME}"
-CANCEL_ODD_RECORDS_MINUTES_INTERVAL=10
-SERVER_PORT=8080
+POSTGRES_HOST="localhost"
+POSTGRES_PORT="5432"
+POSTGRES_USER="user"
+POSTGRES_PASSWORD="12345"
+POSTGRES_DB="entain"
+CANCEL_ODD_RECORDS_MINUTES_INTERVAL=1
+NUMBER_OF_LATEST_RECORDS_FOR_CANCELLING=10
+SERVER_PORT="8080"

.gitignore

@@ -1 +1,2 @@
 .env
+vendor

.golangci.yml

@@ -0,0 +1,57 @@
+run:
+  # Default concurrency is an available CPU number
+  concurrency: 4
+
+  # Include test files or not, default is true
+  tests: true
+
+# Settings of specific linters
+linters-settings:
+  gocyclo:
+    min-complexity: 15
+
+linters:
+  # do not use `enable-all`: it's deprecated and will be removed soon.
+  disable-all: true
+  enable:
+    - asasalint
+    - asciicheck
+    - bidichk
+    - bodyclose
+    - dogsled
+    - durationcheck
+    - errcheck
+    - errchkjson
+    - execinquery
+    - exportloopref
+    - forbidigo
+    - gocognit
+    - gocritic
+    - godox
+    - gofmt
+    - gofumpt
+    - goimports
+    - goprintffuncname
+    - gosimple
+    - govet
+    - ineffassign
+    - misspell
+    - nakedret
+    - nestif
+    - nilerr
+    - nonamedreturns
+    - prealloc
+    - predeclared
+    - revive
+    - staticcheck
+    - stylecheck
+    - tenv
+    - typecheck
+    - unconvert
+    - unparam
+    - unused
+    - usestdlibvars
+    - whitespace
+
+issues:
+  max-same-issues: 0

Dockerfile

@@ -1,20 +1,16 @@
-FROM golang:1.19-alpine3.16 as builder
+FROM golang:1.22.4-alpine3.20
 
 # Set the Current Working Directory inside the container
 WORKDIR /app
 
 # Copy the source from the current directory to the Working Directory inside the container
 COPY . .
 
-# Install git.
-# Git is required for fetching the dependencies.
-RUN apk update && apk add --no-cache git && apk add --no-cache bash && apk add build-base
-
-# Download all dependencies. Dependencies will be cached if the go.mod and the go.sum files are not changed
-RUN go mod download
-
-# Build the Go app
-RUN go build -o main .
+# Install any needed packages specified in go.mod and build the go app
+RUN apk update && \
+    apk add --no-cache git bash build-base && \
+    go mod download && \
+    go build -o main .
 
 # This container exposes port 8080 to the outside world
 EXPOSE ${SERVER_PORT}

Makefile

@@ -3,6 +3,17 @@ include .env
 run:
 	go run main.go
 
+mod-vendor:
+	go mod vendor
+
+linter:
+	@golangci-lint run
+
+gosec:
+	@gosec -quiet ./...
+
+validate: linter gosec
+
 create-migration:
 	@migrate create -ext sql -dir migrations -seq ${name}
 

README.md

@@ -38,7 +38,7 @@ Process record request body example:
 
 Transaction id is unique, so you can't process the same transaction twice, provide UUID v4 format.
 State can be `win` or `lose`.
-Amount is a number, can be positive or negative.
+Amount is a number should be positive but to have a negative balance you should provide a `lose` state.
 
 ### Required header for all endpoints:
 
@@ -61,6 +61,6 @@ This user has 50 amount of his balance for testing.
 ## To run application in docker container:
 
 1. Create `.env` file in root folder and add all required variables from `.env.example` file
-2. To run docker container you should have `docker` and `docker-compose` tools installed (Tested on `docker version 20.10.22, build 3a2c30b` and `docker-compose version 1.26.2, build eefe0d31`)
+2. To run docker container you should have `docker` and `docker-compose` tools installed (Tested on `Docker version 26.1.3, build b72abbb` and `Docker Compose version v2.27.1`)
 3. `docker-compose up` - to run application in docker container
 4. `docker-compose down` - to stop application in docker container

configuration/config.go

@@ -0,0 +1,36 @@
+package configuration
+
+import (
+	"github.com/joho/godotenv"
+	"github.com/spf13/viper"
+)
+
+type Config struct {
+	PostgresHost                       string
+	PostgresPort                       string
+	PostgresUser                       string
+	PostgresPassword                   string
+	PostgresName                       string
+	CancelOddRecordsMinutesInterval    int
+	NumberOfLatestRecordsForCancelling int
+	ServerPort                         string
+}
+
+func Load() (*Config, error) {
+	if err := godotenv.Load(); err != nil {
+		return nil, err
+	}
+
+	viper.AutomaticEnv()
+
+	return &Config{
+		PostgresHost:                       viper.GetString("POSTGRES_HOST"),
+		PostgresPort:                       viper.GetString("POSTGRES_PORT"),
+		PostgresUser:                       viper.GetString("POSTGRES_USER"),
+		PostgresPassword:                   viper.GetString("POSTGRES_PASSWORD"),
+		PostgresName:                       viper.GetString("POSTGRES_DB"),
+		CancelOddRecordsMinutesInterval:    viper.GetInt("CANCEL_ODD_RECORDS_MINUTES_INTERVAL"),
+		NumberOfLatestRecordsForCancelling: viper.GetInt("NUMBER_OF_LATEST_RECORDS_FOR_CANCELLING"),
+		ServerPort:                         viper.GetString("SERVER_PORT"),
+	}, nil
+}

controller/controllers.go

@@ -0,0 +1,28 @@
+package controller
+
+import (
+	"github.com/entain-test-task/configuration"
+	"github.com/entain-test-task/repository"
+	"github.com/entain-test-task/service"
+)
+
+type Controllers struct {
+	User        *User
+	Transaction *Transaction
+}
+
+func NewControllers(
+	cfg *configuration.Config,
+	store *repository.Store,
+) *Controllers {
+	userRepo := repository.NewUser(store)
+	transactionRepo := repository.NewTransaction(store)
+
+	userService := service.NewUser(userRepo)
+	transactionService := service.NewTransaction(transactionRepo, userRepo)
+
+	return &Controllers{
+		User:        NewUser(userService),
+		Transaction: NewTransaction(cfg, transactionService),
+	}
+}

middleware/status_errors.go controller/status_errors.gomiddleware/status_errors.go renamed to controller/status_errors.go

@@ -1,4 +1,4 @@
-package middleware
+package controller
 
 import (
 	"encoding/json"
@@ -8,50 +8,43 @@ import (
 )
 
 func StatusOK(w http.ResponseWriter, response interface{}) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-
-	json.NewEncoder(w).Encode(response)
+	writeJSONResponse(w, http.StatusOK, response)
 }
 
 func StatusInternalServerError(w http.ResponseWriter) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusInternalServerError)
-
-	json.NewEncoder(w).Encode(model.Error{
+	writeJSONResponse(w, http.StatusInternalServerError, model.Error{
 		Message: "Internal Server Error",
 	})
 }
 
 func StatusBadRequest(w http.ResponseWriter, message string) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusBadRequest)
-
-	json.NewEncoder(w).Encode(model.Error{
+	writeJSONResponse(w, http.StatusBadRequest, model.Error{
 		Message: message,
 	})
 }
 
 func StatusUnprocessableEntity(w http.ResponseWriter, message string) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusUnprocessableEntity)
-
-	json.NewEncoder(w).Encode(model.Error{
+	writeJSONResponse(w, http.StatusUnprocessableEntity, model.Error{
 		Message: message,
 	})
 }
 
 func StatusBadRequestWithErrors(w http.ResponseWriter, message string, validationErrors []error) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusBadRequest)
-
 	errorDetails := make([]string, 0)
 	for _, validationError := range validationErrors {
 		errorDetails = append(errorDetails, validationError.Error())
 	}
 
-	json.NewEncoder(w).Encode(model.Error{
+	writeJSONResponse(w, http.StatusBadRequest, model.Error{
 		Message: message,
 		Errors:  errorDetails,
 	})
 }
+
+func writeJSONResponse(w http.ResponseWriter, statusCode int, response interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(statusCode)
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}

controller/transaction.go

@@ -0,0 +1,122 @@
+package controller
+
+import (
+	"encoding/json"
+	"errors"
+	"log"
+	"net/http"
+
+	"github.com/entain-test-task/configuration"
+	"github.com/entain-test-task/model"
+	requestmodel "github.com/entain-test-task/model/request"
+	"github.com/entain-test-task/service"
+	"github.com/go-openapi/strfmt"
+	"github.com/gorilla/mux"
+)
+
+type Transaction struct {
+	cfg       *configuration.Config
+	service   *service.Transaction
+	validator *model.Validator
+}
+
+func NewTransaction(
+	cfg *configuration.Config,
+	service *service.Transaction,
+) *Transaction {
+	return &Transaction{
+		cfg:       cfg,
+		service:   service,
+		validator: model.NewValidator(),
+	}
+}
+
+func (controller *Transaction) GetAllTransactionsByUserID(w http.ResponseWriter, r *http.Request) {
+	params := mux.Vars(r)
+	userID := params["user_id"]
+
+	if !strfmt.IsUUID4(userID) {
+		StatusBadRequest(w, "user_id is not a valid UUID4")
+		return
+	}
+
+	getAllTransactionsByUserIDResponse, err := controller.service.GetAllTransactionsByUserID(strfmt.UUID4(userID))
+	if err != nil {
+		log.Printf("getting all transactions by user ID failed. %v", err)
+		StatusInternalServerError(w)
+		return
+	}
+
+	StatusOK(w, getAllTransactionsByUserIDResponse)
+}
+
+func (controller *Transaction) ProcessRecord(w http.ResponseWriter, r *http.Request) {
+	params := mux.Vars(r)
+	userID := params["user_id"]
+
+	if !strfmt.IsUUID4(userID) {
+		StatusBadRequest(w, "user_id is not a valid UUID4")
+		return
+	}
+
+	var processRecordRequest requestmodel.ProcessRecordRequest
+	if err := json.NewDecoder(r.Body).Decode(&processRecordRequest); err != nil {
+		handleDecodeError(err, w)
+		return
+	}
+
+	validationErrors := controller.validator.ValidateRequest(processRecordRequest)
+	if validationErrors != nil {
+		log.Printf("validating request failed. %v", validationErrors)
+		StatusBadRequestWithErrors(w, "validation error", validationErrors)
+		return
+	}
+
+	processRecordResponse, err := controller.service.ProcessRecord(strfmt.UUID4(userID), processRecordRequest)
+	if err != nil {
+		handleProcessRecordError(w, err)
+		return
+	}
+
+	StatusOK(w, processRecordResponse)
+}
+
+func (controller *Transaction) CancelLatestOddTransactionRecords() {
+	controller.service.CancelLatestOddTransactionRecords(controller.cfg.NumberOfLatestRecordsForCancelling)
+}
+
+func handleProcessRecordError(w http.ResponseWriter, err error) {
+	switch err.Error() {
+	case model.ErrUserNotFound().Error():
+		StatusUnprocessableEntity(w, model.ErrUserNotFound().Error())
+	case model.ErrInsufficientBalance().Error():
+		StatusUnprocessableEntity(w, model.ErrInsufficientBalance().Error())
+	case model.ErrTransactionAlreadyExists().Error():
+		StatusUnprocessableEntity(w, model.ErrTransactionAlreadyExists().Error())
+	default:
+		log.Printf("%s. %v", "processing record failed", err)
+		StatusInternalServerError(w)
+	}
+}
+
+func handleDecodeError(err error, w http.ResponseWriter) {
+	if err == nil {
+		return
+	}
+
+	handleUnmarshalTypeError(err, w)
+
+	log.Printf("decoding request failed. %v", err)
+	StatusInternalServerError(w)
+}
+
+func handleUnmarshalTypeError(err error, w http.ResponseWriter) {
+	typeErr, ok := err.(*json.UnmarshalTypeError)
+	if !ok {
+		return
+	}
+
+	StatusBadRequestWithErrors(w, "validation error", []error{
+		errors.New(typeErr.Field + " is not within allowed range"),
+	})
+}