From 3879c9bd24417d0c5464456b46ed1bf6890af248 Mon Sep 17 00:00:00 2001 From: Michael Makarochkin Date: Thu, 6 Mar 2025 07:47:26 +0300 Subject: [PATCH] Refactory packages --- pink_fox_app/internal/app/cmd/server.go | 42 ------ pink_fox_app/internal/controllers/Index.go | 23 ---- .../manager_route/manager_route.go | 115 ----------------- .../http_server/registration_routes.go | 16 --- pink_fox_app/internal/http_server/server.go | 27 ---- pink_fox_app/internal/inject/DI.go | 26 ---- pink_fox_app/internal/inject/types.go | 11 -- pink_fox_app/main.go | 2 +- pink_fox_app/{internal => src}/app/app.go | 8 +- pink_fox_app/{internal => src}/app/cmd/cmd.go | 0 pink_fox_app/src/app/cmd/server.go | 64 +++++++++ .../{internal => src}/app/config/config.go | 2 +- pink_fox_app/{internal => src}/app/db/db.go | 2 +- .../app/http_server}/response-factory.go | 2 +- .../http => src/app/http_server}/response.go | 2 +- .../{pkg => src/app}/lerror/lerror.go | 0 .../app/log => src/app/logger}/log.go | 2 +- .../src/app/routes_manager/manager.go | 121 ++++++++++++++++++ .../{internal => src}/app/timer/timer.go | 0 pink_fox_app/src/controllers/Index.go | 23 ++++ pink_fox_app/src/dependence/container.go | 26 ++++ pink_fox_app/src/routes/registration.go | 16 +++ 22 files changed, 260 insertions(+), 270 deletions(-) delete mode 100644 pink_fox_app/internal/app/cmd/server.go delete mode 100644 pink_fox_app/internal/controllers/Index.go delete mode 100644 pink_fox_app/internal/http_server/manager_route/manager_route.go delete mode 100644 pink_fox_app/internal/http_server/registration_routes.go delete mode 100644 pink_fox_app/internal/http_server/server.go delete mode 100644 pink_fox_app/internal/inject/DI.go delete mode 100644 pink_fox_app/internal/inject/types.go rename pink_fox_app/{internal => src}/app/app.go (53%) rename pink_fox_app/{internal => src}/app/cmd/cmd.go (100%) create mode 100644 pink_fox_app/src/app/cmd/server.go rename pink_fox_app/{internal => src}/app/config/config.go (94%) rename pink_fox_app/{internal => src}/app/db/db.go (95%) rename pink_fox_app/{internal/http_server/http => src/app/http_server}/response-factory.go (93%) rename pink_fox_app/{internal/http_server/http => src/app/http_server}/response.go (94%) rename pink_fox_app/{pkg => src/app}/lerror/lerror.go (100%) rename pink_fox_app/{internal/app/log => src/app/logger}/log.go (97%) create mode 100644 pink_fox_app/src/app/routes_manager/manager.go rename pink_fox_app/{internal => src}/app/timer/timer.go (100%) create mode 100644 pink_fox_app/src/controllers/Index.go create mode 100644 pink_fox_app/src/dependence/container.go create mode 100644 pink_fox_app/src/routes/registration.go diff --git a/pink_fox_app/internal/app/cmd/server.go b/pink_fox_app/internal/app/cmd/server.go deleted file mode 100644 index 71d2986..0000000 --- a/pink_fox_app/internal/app/cmd/server.go +++ /dev/null @@ -1,42 +0,0 @@ -package cmd - -import ( - "database/sql" - "pink_fox/internal/app" - conf2 "pink_fox/internal/app/config" - "pink_fox/internal/app/db" - "pink_fox/internal/app/log" - "pink_fox/internal/http_server" -) - -type Server struct { -} - -func NewServer() *Server { - return &Server{} -} - -func (it *Server) Execute(defaultConfig string, defaultPort int) error { - conf, err := conf2.LoadConfig(defaultConfig, defaultPort) - if err != nil { - exit(err) - } - - conn, err := db.CreateConnection(&conf.Db) - if err != nil { - exit(err) - } - defer func(conn *sql.DB) { - _ = conn.Close() - }(conn) - - logger, err := log.NewLogger(conf.LogFile) - if err != nil { - exit(err) - } - defer func(logger *log.Logger) { - _ = logger.Close() - }(logger) - - return http_server.StartServer(app.New(conf, conn, logger)) -} diff --git a/pink_fox_app/internal/controllers/Index.go b/pink_fox_app/internal/controllers/Index.go deleted file mode 100644 index e0edb61..0000000 --- a/pink_fox_app/internal/controllers/Index.go +++ /dev/null @@ -1,23 +0,0 @@ -package controllers - -import ( - "pink_fox/internal/http_server/http" -) - -type IndexController struct { - responseFactory *http.ResponseFactory -} - -type IndexControllerDI interface { - MakeResponseFactory() *http.ResponseFactory -} - -func NewIndexController(di IndexControllerDI) *IndexController { - return &IndexController{ - responseFactory: di.MakeResponseFactory(), - } -} - -func (it *IndexController) ActionIndex() http.Response { - return it.responseFactory.String("Hello world!") -} diff --git a/pink_fox_app/internal/http_server/manager_route/manager_route.go b/pink_fox_app/internal/http_server/manager_route/manager_route.go deleted file mode 100644 index 144f33a..0000000 --- a/pink_fox_app/internal/http_server/manager_route/manager_route.go +++ /dev/null @@ -1,115 +0,0 @@ -package manager_route - -import ( - "github.com/gin-gonic/gin" - "pink_fox/internal/app" - "pink_fox/internal/http_server/http" - "pink_fox/internal/inject" -) - -type Manager struct { - engine *gin.Engine - application *app.Application - middlewares []inject.MiddlewareFunc -} - -func NewManager(e *gin.Engine, application *app.Application) *Manager { - return &Manager{ - engine: e, - application: application, - middlewares: make([]inject.MiddlewareFunc, 0), - } -} - -func (it *Manager) Group(relativePath string, middlewares ...inject.MiddlewareFunc) *Group { - return NewGroup(it, relativePath, middlewares...) -} - -func (it *Manager) Use(middlewares ...inject.MiddlewareFunc) { - it.middlewares = append(it.middlewares, middlewares...) -} - -func (it *Manager) ANY(relativePath string, handler inject.HandlerFunc, middlewares ...inject.MiddlewareFunc) { - handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.application) - it.engine.GET(relativePath, handlerForGin) - it.engine.POST(relativePath, handlerForGin) -} - -func (it *Manager) GET(relativePath string, handler inject.HandlerFunc, middlewares ...inject.MiddlewareFunc) { - handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.application) - it.engine.GET(relativePath, handlerForGin) -} - -func (it *Manager) POST(relativePath string, handler inject.HandlerFunc, middlewares ...inject.MiddlewareFunc) { - handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.application) - it.engine.POST(relativePath, handlerForGin) -} - -type Group struct { - manager *Manager - relativePath string - middlewares []inject.MiddlewareFunc -} - -func NewGroup(route *Manager, relativePath string, middlewares ...inject.MiddlewareFunc) *Group { - return &Group{ - manager: route, - relativePath: relativePath, - middlewares: append(route.middlewares, middlewares...), - } -} - -func (it *Group) Group(relativePath string, middlewares ...inject.MiddlewareFunc) *Group { - return &Group{ - manager: it.manager, - relativePath: it.relativePath + relativePath, - middlewares: append(it.middlewares, middlewares...), - } -} - -func (it *Group) Use(middlewares ...inject.MiddlewareFunc) { - it.middlewares = append(it.middlewares, middlewares...) -} - -func (it *Group) ANY(relativePath string, handler inject.HandlerFunc, middlewares ...inject.MiddlewareFunc) { - handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.manager.application) - it.manager.engine.GET(it.relativePath+relativePath, handlerForGin) - it.manager.engine.POST(it.relativePath+relativePath, handlerForGin) -} - -func (it *Group) GET(relativePath string, handler inject.HandlerFunc, middlewares ...inject.MiddlewareFunc) { - handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.manager.application) - it.manager.engine.GET(it.relativePath+relativePath, handlerForGin) -} - -func (it *Group) POST(relativePath string, handler inject.HandlerFunc, middlewares ...inject.MiddlewareFunc) { - handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.manager.application) - it.manager.engine.POST(it.relativePath+relativePath, handlerForGin) -} - -func makeHandlerGin(handler inject.HandlerFunc, middlewares []inject.MiddlewareFunc, application *app.Application) gin.HandlerFunc { - return func(ctx *gin.Context) { - di := inject.NewDI(application, ctx) - defer di.Close() - res := pipeline(handler, middlewares, di) - res.Render() - } -} - -func pipeline(endpoint inject.HandlerFunc, middlewares []inject.MiddlewareFunc, di *inject.DI) http.Response { - handler := func() http.Response { - return endpoint(di) - } - - for i := len(middlewares) - 1; i >= 0; i-- { - handler = createMiddleware(handler, middlewares[i], di) - } - - return handler() -} - -func createMiddleware(next inject.ActionFunc, middleware inject.MiddlewareFunc, di *inject.DI) inject.ActionFunc { - return func() http.Response { - return middleware(di, next) - } -} diff --git a/pink_fox_app/internal/http_server/registration_routes.go b/pink_fox_app/internal/http_server/registration_routes.go deleted file mode 100644 index a53fcf4..0000000 --- a/pink_fox_app/internal/http_server/registration_routes.go +++ /dev/null @@ -1,16 +0,0 @@ -package http_server - -import ( - "pink_fox/internal/controllers" - "pink_fox/internal/http_server/http" - "pink_fox/internal/http_server/manager_route" - "pink_fox/internal/inject" -) - -func RegistrationRoutes(r *manager_route.Manager) { - r.GET("/", IndexController) -} - -func IndexController(di *inject.DI) http.Response { - return controllers.NewIndexController(di).ActionIndex() -} diff --git a/pink_fox_app/internal/http_server/server.go b/pink_fox_app/internal/http_server/server.go deleted file mode 100644 index 6284e0d..0000000 --- a/pink_fox_app/internal/http_server/server.go +++ /dev/null @@ -1,27 +0,0 @@ -package http_server - -import ( - "fmt" - "github.com/gin-gonic/gin" - "net/http" - "pink_fox/internal/app" - "pink_fox/internal/http_server/manager_route" -) - -func StartServer(application *app.Application) error { - r := gin.Default() - _ = r.SetTrustedProxies(nil) - r.GET("/ping", func(c *gin.Context) { - c.String(http.StatusOK, "ok") - }) - - RegistrationRoutes(manager_route.NewManager(r, application)) - - fmt.Printf("Starting http_server at port %d...", application.Conf.Port) - err := r.Run(fmt.Sprintf(":%d", application.Conf.Port)) - if err != nil { - return err - } - - return nil -} diff --git a/pink_fox_app/internal/inject/DI.go b/pink_fox_app/internal/inject/DI.go deleted file mode 100644 index 6f8495e..0000000 --- a/pink_fox_app/internal/inject/DI.go +++ /dev/null @@ -1,26 +0,0 @@ -package inject - -import ( - "github.com/gin-gonic/gin" - "pink_fox/internal/app" - "pink_fox/internal/http_server/http" -) - -type DI struct { - application *app.Application - context *gin.Context -} - -func NewDI(application *app.Application, ctx *gin.Context) *DI { - return &DI{ - application: application, - context: ctx, - } -} - -func (it *DI) Close() { -} - -func (it *DI) MakeResponseFactory() *http.ResponseFactory { - return http.NewResponseFactory(it.context) -} diff --git a/pink_fox_app/internal/inject/types.go b/pink_fox_app/internal/inject/types.go deleted file mode 100644 index 053ecf0..0000000 --- a/pink_fox_app/internal/inject/types.go +++ /dev/null @@ -1,11 +0,0 @@ -package inject - -import ( - "pink_fox/internal/http_server/http" -) - -type MiddlewareFunc func(*DI, ActionFunc) http.Response - -type HandlerFunc func(*DI) http.Response - -type ActionFunc func() http.Response diff --git a/pink_fox_app/main.go b/pink_fox_app/main.go index c0a5a50..4a0add9 100644 --- a/pink_fox_app/main.go +++ b/pink_fox_app/main.go @@ -3,7 +3,7 @@ package main import ( "fmt" "os" - "pink_fox/internal/app/cmd" + "pink_fox/src/app/cmd" ) func main() { diff --git a/pink_fox_app/internal/app/app.go b/pink_fox_app/src/app/app.go similarity index 53% rename from pink_fox_app/internal/app/app.go rename to pink_fox_app/src/app/app.go index 74bcc2d..e81d7fb 100644 --- a/pink_fox_app/internal/app/app.go +++ b/pink_fox_app/src/app/app.go @@ -2,17 +2,17 @@ package app import ( "database/sql" - "pink_fox/internal/app/config" - "pink_fox/internal/app/log" + "pink_fox/src/app/config" + "pink_fox/src/app/logger" ) type Application struct { Conf *config.Config Conn *sql.DB - Logger *log.Logger + Logger *logger.Logger } -func New(conf *config.Config, conn *sql.DB, logger *log.Logger) *Application { +func New(conf *config.Config, conn *sql.DB, logger *logger.Logger) *Application { return &Application{ Conf: conf, Conn: conn, diff --git a/pink_fox_app/internal/app/cmd/cmd.go b/pink_fox_app/src/app/cmd/cmd.go similarity index 100% rename from pink_fox_app/internal/app/cmd/cmd.go rename to pink_fox_app/src/app/cmd/cmd.go diff --git a/pink_fox_app/src/app/cmd/server.go b/pink_fox_app/src/app/cmd/server.go new file mode 100644 index 0000000..bb00c6f --- /dev/null +++ b/pink_fox_app/src/app/cmd/server.go @@ -0,0 +1,64 @@ +package cmd + +import ( + "database/sql" + "fmt" + "github.com/gin-gonic/gin" + "net/http" + "pink_fox/src/app" + c "pink_fox/src/app/config" + "pink_fox/src/app/db" + l "pink_fox/src/app/logger" + "pink_fox/src/app/routes_manager" + "pink_fox/src/routes" +) + +type Server struct { +} + +func NewServer() *Server { + return &Server{} +} + +func (it *Server) Execute(defaultConfig string, defaultPort int) error { + conf, err := c.LoadConfig(defaultConfig, defaultPort) + if err != nil { + exit(err) + } + + conn, err := db.CreateConnection(&conf.Db) + if err != nil { + exit(err) + } + defer func(conn *sql.DB) { + _ = conn.Close() + }(conn) + + logger, err := l.NewLogger(conf.LogFile) + if err != nil { + exit(err) + } + defer func(logger *l.Logger) { + _ = logger.Close() + }(logger) + + return it.StartServer(app.New(conf, conn, logger)) +} + +func (it *Server) StartServer(application *app.Application) error { + r := gin.Default() + _ = r.SetTrustedProxies(nil) + r.GET("/ping", func(c *gin.Context) { + c.String(http.StatusOK, "ok") + }) + + routes.RegistrationRoutes(routes_manager.NewManager(r, application)) + + fmt.Printf("Starting http_server at port %d...", application.Conf.Port) + err := r.Run(fmt.Sprintf(":%d", application.Conf.Port)) + if err != nil { + return err + } + + return nil +} diff --git a/pink_fox_app/internal/app/config/config.go b/pink_fox_app/src/app/config/config.go similarity index 94% rename from pink_fox_app/internal/app/config/config.go rename to pink_fox_app/src/app/config/config.go index 056143e..e42d6ca 100644 --- a/pink_fox_app/internal/app/config/config.go +++ b/pink_fox_app/src/app/config/config.go @@ -38,7 +38,7 @@ func setDefaultValue(conf *Config, defaultPort int) *Config { conf.Port = defaultPort } if conf.LogFile == "" { - conf.LogFile = "/var/log/pink_fox/app.log" + conf.LogFile = "/var/logger/pink_fox/app.logger" } return conf } diff --git a/pink_fox_app/internal/app/db/db.go b/pink_fox_app/src/app/db/db.go similarity index 95% rename from pink_fox_app/internal/app/db/db.go rename to pink_fox_app/src/app/db/db.go index 9f1ecee..2f363c2 100644 --- a/pink_fox_app/internal/app/db/db.go +++ b/pink_fox_app/src/app/db/db.go @@ -4,7 +4,7 @@ import ( "database/sql" "fmt" _ "github.com/lib/pq" - "pink_fox/internal/app/config" + "pink_fox/src/app/config" "time" ) diff --git a/pink_fox_app/internal/http_server/http/response-factory.go b/pink_fox_app/src/app/http_server/response-factory.go similarity index 93% rename from pink_fox_app/internal/http_server/http/response-factory.go rename to pink_fox_app/src/app/http_server/response-factory.go index 28a164b..5995894 100644 --- a/pink_fox_app/internal/http_server/http/response-factory.go +++ b/pink_fox_app/src/app/http_server/response-factory.go @@ -1,4 +1,4 @@ -package http +package http_server import ( "github.com/gin-gonic/gin" diff --git a/pink_fox_app/internal/http_server/http/response.go b/pink_fox_app/src/app/http_server/response.go similarity index 94% rename from pink_fox_app/internal/http_server/http/response.go rename to pink_fox_app/src/app/http_server/response.go index 682367d..006b9a9 100644 --- a/pink_fox_app/internal/http_server/http/response.go +++ b/pink_fox_app/src/app/http_server/response.go @@ -1,4 +1,4 @@ -package http +package http_server import ( "github.com/gin-gonic/gin" diff --git a/pink_fox_app/pkg/lerror/lerror.go b/pink_fox_app/src/app/lerror/lerror.go similarity index 100% rename from pink_fox_app/pkg/lerror/lerror.go rename to pink_fox_app/src/app/lerror/lerror.go diff --git a/pink_fox_app/internal/app/log/log.go b/pink_fox_app/src/app/logger/log.go similarity index 97% rename from pink_fox_app/internal/app/log/log.go rename to pink_fox_app/src/app/logger/log.go index f943502..1297435 100644 --- a/pink_fox_app/internal/app/log/log.go +++ b/pink_fox_app/src/app/logger/log.go @@ -1,4 +1,4 @@ -package log +package logger import ( "fmt" diff --git a/pink_fox_app/src/app/routes_manager/manager.go b/pink_fox_app/src/app/routes_manager/manager.go new file mode 100644 index 0000000..b93082e --- /dev/null +++ b/pink_fox_app/src/app/routes_manager/manager.go @@ -0,0 +1,121 @@ +package routes_manager + +import ( + "github.com/gin-gonic/gin" + "pink_fox/src/app" + "pink_fox/src/app/http_server" + "pink_fox/src/dependence" +) + +type RoutesManager struct { + engine *gin.Engine + application *app.Application + middlewares []MiddlewareFunc +} + +func NewManager(e *gin.Engine, application *app.Application) *RoutesManager { + return &RoutesManager{ + engine: e, + application: application, + middlewares: make([]MiddlewareFunc, 0), + } +} + +type MiddlewareFunc func(*dependence.Container, ActionFunc) http_server.Response + +type HandlerFunc func(container *dependence.Container) http_server.Response + +type ActionFunc func() http_server.Response + +func (it *RoutesManager) Group(relativePath string, middlewares ...MiddlewareFunc) *Group { + return NewGroup(it, relativePath, middlewares...) +} + +func (it *RoutesManager) Use(middlewares ...MiddlewareFunc) { + it.middlewares = append(it.middlewares, middlewares...) +} + +func (it *RoutesManager) ANY(relativePath string, handler HandlerFunc, middlewares ...MiddlewareFunc) { + handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.application) + it.engine.GET(relativePath, handlerForGin) + it.engine.POST(relativePath, handlerForGin) +} + +func (it *RoutesManager) GET(relativePath string, handler HandlerFunc, middlewares ...MiddlewareFunc) { + handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.application) + it.engine.GET(relativePath, handlerForGin) +} + +func (it *RoutesManager) POST(relativePath string, handler HandlerFunc, middlewares ...MiddlewareFunc) { + handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.application) + it.engine.POST(relativePath, handlerForGin) +} + +type Group struct { + routesManager *RoutesManager + relativePath string + middlewares []MiddlewareFunc +} + +func NewGroup(route *RoutesManager, relativePath string, middlewares ...MiddlewareFunc) *Group { + return &Group{ + routesManager: route, + relativePath: relativePath, + middlewares: append(route.middlewares, middlewares...), + } +} + +func (it *Group) Group(relativePath string, middlewares ...MiddlewareFunc) *Group { + return &Group{ + routesManager: it.routesManager, + relativePath: it.relativePath + relativePath, + middlewares: append(it.middlewares, middlewares...), + } +} + +func (it *Group) Use(middlewares ...MiddlewareFunc) { + it.middlewares = append(it.middlewares, middlewares...) +} + +func (it *Group) ANY(relativePath string, handler HandlerFunc, middlewares ...MiddlewareFunc) { + handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.routesManager.application) + it.routesManager.engine.GET(it.relativePath+relativePath, handlerForGin) + it.routesManager.engine.POST(it.relativePath+relativePath, handlerForGin) +} + +func (it *Group) GET(relativePath string, handler HandlerFunc, middlewares ...MiddlewareFunc) { + handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.routesManager.application) + it.routesManager.engine.GET(it.relativePath+relativePath, handlerForGin) +} + +func (it *Group) POST(relativePath string, handler HandlerFunc, middlewares ...MiddlewareFunc) { + handlerForGin := makeHandlerGin(handler, append(it.middlewares, middlewares...), it.routesManager.application) + it.routesManager.engine.POST(it.relativePath+relativePath, handlerForGin) +} + +func makeHandlerGin(handler HandlerFunc, middlewares []MiddlewareFunc, application *app.Application) gin.HandlerFunc { + return func(ctx *gin.Context) { + dic := dependence.NewContainer(application, ctx) + defer dic.Close() + res := pipeline(handler, middlewares, dic) + res.Render() + } +} + +func pipeline(endpoint HandlerFunc, middlewares []MiddlewareFunc, di *dependence.Container) http_server.Response { + handler := func() http_server.Response { + return endpoint(di) + } + + for i := len(middlewares) - 1; i >= 0; i-- { + handler = createMiddleware(handler, middlewares[i], di) + } + + return handler() +} + +func createMiddleware(next ActionFunc, middleware MiddlewareFunc, di *dependence.Container) ActionFunc { + return func() http_server.Response { + return middleware(di, next) + } +} diff --git a/pink_fox_app/internal/app/timer/timer.go b/pink_fox_app/src/app/timer/timer.go similarity index 100% rename from pink_fox_app/internal/app/timer/timer.go rename to pink_fox_app/src/app/timer/timer.go diff --git a/pink_fox_app/src/controllers/Index.go b/pink_fox_app/src/controllers/Index.go new file mode 100644 index 0000000..993fcc6 --- /dev/null +++ b/pink_fox_app/src/controllers/Index.go @@ -0,0 +1,23 @@ +package controllers + +import ( + "pink_fox/src/app/http_server" +) + +type IndexController struct { + responseFactory *http_server.ResponseFactory +} + +type IndexControllerContainer interface { + MakeResponseFactory() *http_server.ResponseFactory +} + +func NewIndexController(di IndexControllerContainer) *IndexController { + return &IndexController{ + responseFactory: di.MakeResponseFactory(), + } +} + +func (it *IndexController) ActionIndex() http_server.Response { + return it.responseFactory.String("Hello world!") +} diff --git a/pink_fox_app/src/dependence/container.go b/pink_fox_app/src/dependence/container.go new file mode 100644 index 0000000..4122a81 --- /dev/null +++ b/pink_fox_app/src/dependence/container.go @@ -0,0 +1,26 @@ +package dependence + +import ( + "github.com/gin-gonic/gin" + "pink_fox/src/app" + "pink_fox/src/app/http_server" +) + +type Container struct { + application *app.Application + context *gin.Context +} + +func NewContainer(application *app.Application, context *gin.Context) *Container { + return &Container{ + application: application, + context: context, + } +} + +func (it *Container) Close() { +} + +func (it *Container) MakeResponseFactory() *http_server.ResponseFactory { + return nil +} diff --git a/pink_fox_app/src/routes/registration.go b/pink_fox_app/src/routes/registration.go new file mode 100644 index 0000000..5efde75 --- /dev/null +++ b/pink_fox_app/src/routes/registration.go @@ -0,0 +1,16 @@ +package routes + +import ( + "pink_fox/src/app/http_server" + "pink_fox/src/app/routes_manager" + "pink_fox/src/controllers" + di "pink_fox/src/dependence" +) + +func RegistrationRoutes(r *routes_manager.RoutesManager) { + r.GET("/", IndexController) +} + +func IndexController(dic *di.Container) http_server.Response { + return controllers.NewIndexController(dic).ActionIndex() +}