-
Notifications
You must be signed in to change notification settings - Fork 0
/
main.go
127 lines (102 loc) · 4.14 KB
/
main.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package main
import (
"fmt"
"github.com/go-chi/chi"
"github.com/kelseyhightower/envconfig"
adpterHttpInput "github.com/petshop-system/petshop-api/adapter/input/http"
"github.com/petshop-system/petshop-api/adapter/input/http/handler"
"github.com/petshop-system/petshop-api/adapter/input/message/stream"
"github.com/petshop-system/petshop-api/adapter/output/cache"
"github.com/petshop-system/petshop-api/adapter/output/database"
"github.com/petshop-system/petshop-api/application/service"
"github.com/petshop-system/petshop-api/configuration/environment"
"github.com/petshop-system/petshop-api/configuration/repository"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
"net/http"
"os"
)
var loggerSugar *zap.SugaredLogger
func init() {
err := envconfig.Process("setting", &environment.Setting)
if err != nil {
panic(err.Error())
}
config := zap.NewProductionEncoderConfig()
config.EncodeTime = zapcore.ISO8601TimeEncoder
jsonEncoder := zapcore.NewJSONEncoder(config)
core := zapcore.NewTee(
zapcore.NewCore(jsonEncoder, zapcore.AddSync(os.Stdout), zapcore.DebugLevel),
)
logger := zap.New(core, zap.AddCaller())
defer logger.Sync() // flushes buffer, if any
loggerSugar = logger.Sugar()
}
func main() {
redisCache := cache.NewRedis(loggerSugar)
postgresConnectionDB := repository.NewPostgresDB(environment.Setting.Postgres.DBUser, environment.Setting.Postgres.DBPassword,
environment.Setting.Postgres.DBName, environment.Setting.Postgres.DBHost, environment.Setting.Postgres.DBPort, loggerSugar)
customerPostgresDB := database.NewCustomerPostgresDB(postgresConnectionDB, loggerSugar)
addressPostgresDB := database.NewAddressPostgresDB(postgresConnectionDB, loggerSugar)
phonePostgresDB := database.NewPhonePostgresDB(postgresConnectionDB, loggerSugar)
genericHandler := &handler.Generic{
LoggerSugar: loggerSugar,
}
customerService := &service.CustomerService{
LoggerSugar: loggerSugar,
CustomerDomainDataBaseRepository: &customerPostgresDB,
CustomerDomainCacheRepository: &redisCache,
}
customerHandler := &handler.Customer{
CustomerService: customerService,
LoggerSugar: loggerSugar,
}
addressService := service.AddressService{
LoggerSugar: loggerSugar,
AddressDomainDataBaseRepository: &addressPostgresDB,
AddressDomainCacheRepository: &redisCache,
}
addressHandler := &handler.Address{
AddressService: addressService,
LoggerSugar: loggerSugar,
}
phoneService := &service.PhoneService{
LoggerSugar: loggerSugar,
PhoneDomainDataBaseRepository: &phonePostgresDB,
PhoneDomainCacheRepository: &redisCache,
}
phoneHandler := &handler.Phone{
PhoneService: phoneService,
LoggerSugar: loggerSugar,
}
scheduleService := &service.ScheduleService{
LoggerSugar: loggerSugar,
}
scheduleKafkaClient := stream.NewScheduleKafkaClient(loggerSugar, scheduleService, environment.Setting.Kafka.Schedule.BootstrapServer,
environment.Setting.Kafka.Schedule.GroupID, environment.Setting.Kafka.Schedule.AutoOffsetReset,
environment.Setting.Kafka.Schedule.Topic)
scheduleKafkaClient.ConsumerMessages()
contextPath := environment.Setting.Server.Context
newRouter := adpterHttpInput.GetNewRouter(loggerSugar)
newRouter.GetChiRouter().Route(fmt.Sprintf("/%s", contextPath), func(r chi.Router) {
r.NotFound(genericHandler.NotFound)
r.Group(newRouter.AddGroupHandlerHealthCheck(genericHandler))
r.Group(newRouter.AddGroupHandlerCustomer(customerHandler))
r.Group(newRouter.AddGroupHandlerAddress(addressHandler))
r.Group(newRouter.AddGroupHandlerPhone(phoneHandler))
})
serverHttp := &http.Server{
Addr: fmt.Sprintf(":%s", environment.Setting.Server.Port),
Handler: newRouter.GetChiRouter(),
ReadTimeout: environment.Setting.Server.ReadTimeout,
WriteTimeout: environment.Setting.Server.WriteTimeout,
MaxHeaderBytes: 1 << 20,
}
loggerSugar.Infow("server started", "port", serverHttp.Addr,
"contextPath", contextPath)
if err := serverHttp.ListenAndServe(); err != nil {
loggerSugar.Errorw("error to listen and starts server", "port", serverHttp.Addr,
"contextPath", contextPath, "err", err.Error())
panic(err.Error())
}
}