278 lines
8.3 KiB
Go
278 lines
8.3 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/cmd/internal"
|
|
"github.com/Kichiyaki/appmode"
|
|
"github.com/Kichiyaki/chilogrus"
|
|
"github.com/Kichiyaki/goutil/envutil"
|
|
"github.com/getsentry/sentry-go"
|
|
sentryhttp "github.com/getsentry/sentry-go/http"
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-pg/pg/v10"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"time"
|
|
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/auth"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/chi/middleware"
|
|
graphqlhttpdelivery "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/graphql/delivery/httpdelivery"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/graphql/directive"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/graphql/resolvers"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/profession"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/qualification"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/question"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/user"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/auth/jwt"
|
|
authusecase "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/auth/usecase"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/graphql/dataloader"
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/postgres"
|
|
professionrepository "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/profession/repository"
|
|
professionusecase "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/profession/usecase"
|
|
qualificationrepository "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/qualification/repository"
|
|
qualificationusecase "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/qualification/usecase"
|
|
questionrepository "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/question/repository"
|
|
questionusecase "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/question/usecase"
|
|
userrepository "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/user/repository"
|
|
userusecase "gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/internal/user/usecase"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
|
|
"gitea.dwysokinski.me/zdam-egzamin-zawodowy/backend/fstorage"
|
|
|
|
chimiddleware "github.com/go-chi/chi/v5/middleware"
|
|
"github.com/go-chi/cors"
|
|
)
|
|
|
|
var (
|
|
Version = "development"
|
|
)
|
|
|
|
func main() {
|
|
if err := internal.LoadENVFiles(); err != nil {
|
|
logrus.Fatal("internal.LoadENVFiles", err)
|
|
}
|
|
|
|
prepareLogger()
|
|
|
|
if err := internal.InitSentry(Version); err != nil {
|
|
logrus.Fatal("internal.InitSentry", err)
|
|
}
|
|
defer sentry.Flush(2 * time.Second)
|
|
|
|
fileStorage := fstorage.New(&fstorage.Config{
|
|
BasePath: envutil.GetenvString("FILE_STORAGE_PATH"),
|
|
})
|
|
|
|
dbConn, err := postgres.Connect(&postgres.Config{
|
|
LogQueries: envutil.GetenvBool("LOG_DB_QUERIES"),
|
|
})
|
|
if err != nil {
|
|
logrus.Fatal(errors.Wrap(err, "Couldn't connect to the db"))
|
|
}
|
|
|
|
repos, err := prepareRepositories(dbConn, fileStorage)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
ucases, err := prepareUsecases(repos)
|
|
if err != nil {
|
|
logrus.Fatal(err)
|
|
}
|
|
|
|
srv := &http.Server{
|
|
Addr: ":8080",
|
|
Handler: prepareRouter(repos, ucases),
|
|
}
|
|
go func() {
|
|
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
|
logrus.Fatalln("listen:", err)
|
|
}
|
|
}()
|
|
logrus.Info("Server is listening on the port 8080")
|
|
|
|
quit := make(chan os.Signal)
|
|
signal.Notify(quit, os.Interrupt)
|
|
<-quit
|
|
logrus.Info("Shutdown signal received, exiting...")
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
if err := srv.Shutdown(ctx); err != nil {
|
|
logrus.Fatalln("Server Shutdown:", err)
|
|
}
|
|
}
|
|
|
|
func prepareLogger() {
|
|
if appmode.Equals(appmode.DevelopmentMode) {
|
|
logrus.SetLevel(logrus.DebugLevel)
|
|
}
|
|
|
|
timestampFormat := "2006-01-02 15:04:05"
|
|
if appmode.Equals(appmode.ProductionMode) {
|
|
customFormatter := new(logrus.JSONFormatter)
|
|
customFormatter.TimestampFormat = timestampFormat
|
|
logrus.SetFormatter(customFormatter)
|
|
} else {
|
|
customFormatter := new(logrus.TextFormatter)
|
|
customFormatter.TimestampFormat = timestampFormat
|
|
customFormatter.FullTimestamp = true
|
|
logrus.SetFormatter(customFormatter)
|
|
}
|
|
}
|
|
|
|
type repositories struct {
|
|
userRepository user.Repository
|
|
professionRepository profession.Repository
|
|
qualificationRepository qualification.Repository
|
|
questionRepository question.Repository
|
|
}
|
|
|
|
func prepareRepositories(dbConn *pg.DB, fileStorage fstorage.FileStorage) (*repositories, error) {
|
|
var err error
|
|
repos := &repositories{}
|
|
|
|
repos.userRepository, err = userrepository.NewPGRepository(&userrepository.PGRepositoryConfig{
|
|
DB: dbConn,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "userRepository")
|
|
}
|
|
|
|
repos.professionRepository, err = professionrepository.NewPGRepository(&professionrepository.PGRepositoryConfig{
|
|
DB: dbConn,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "professionRepository")
|
|
}
|
|
|
|
repos.qualificationRepository, err = qualificationrepository.NewPGRepository(&qualificationrepository.PGRepositoryConfig{
|
|
DB: dbConn,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "qualificationRepository")
|
|
}
|
|
|
|
repos.questionRepository, err = questionrepository.NewPGRepository(&questionrepository.PGRepositoryConfig{
|
|
DB: dbConn,
|
|
FileStorage: fileStorage,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "questionRepository")
|
|
}
|
|
|
|
return repos, nil
|
|
}
|
|
|
|
type usecases struct {
|
|
authUsecase auth.Usecase
|
|
userUsecase user.Usecase
|
|
professionUsecase profession.Usecase
|
|
qualificationUsecase qualification.Usecase
|
|
questionUsecase question.Usecase
|
|
}
|
|
|
|
func prepareUsecases(repos *repositories) (*usecases, error) {
|
|
var err error
|
|
ucases := &usecases{}
|
|
|
|
ucases.authUsecase, err = authusecase.New(&authusecase.Config{
|
|
UserRepository: repos.userRepository,
|
|
TokenGenerator: jwt.NewTokenGenerator(envutil.GetenvString("ACCESS_SECRET")),
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "authUsecase")
|
|
}
|
|
|
|
ucases.userUsecase, err = userusecase.New(&userusecase.Config{
|
|
UserRepository: repos.userRepository,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "userUsecase")
|
|
}
|
|
|
|
ucases.professionUsecase, err = professionusecase.New(&professionusecase.Config{
|
|
ProfessionRepository: repos.professionRepository,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "professionUsecase")
|
|
}
|
|
|
|
ucases.qualificationUsecase, err = qualificationusecase.New(&qualificationusecase.Config{
|
|
QualificationRepository: repos.qualificationRepository,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "qualificationUsecase")
|
|
}
|
|
|
|
ucases.questionUsecase, err = questionusecase.New(&questionusecase.Config{
|
|
QuestionRepository: repos.questionRepository,
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "questionUsecase")
|
|
}
|
|
|
|
return ucases, nil
|
|
}
|
|
|
|
func prepareRouter(repos *repositories, ucases *usecases) *chi.Mux {
|
|
r := chi.NewRouter()
|
|
|
|
sentryHandler := sentryhttp.New(sentryhttp.Options{
|
|
Repanic: true,
|
|
WaitForDelivery: false,
|
|
Timeout: 2 * time.Second,
|
|
})
|
|
|
|
r.Use(chimiddleware.RealIP)
|
|
if envutil.GetenvBool("ENABLE_ACCESS_LOG") {
|
|
r.Use(chilogrus.Logger(logrus.StandardLogger()))
|
|
}
|
|
r.Use(chimiddleware.Recoverer)
|
|
r.Use(sentryHandler.Handle)
|
|
|
|
if appmode.Equals(appmode.DevelopmentMode) {
|
|
r.Use(cors.Handler(cors.Options{
|
|
AllowOriginFunc: func(*http.Request, string) bool {
|
|
return true
|
|
},
|
|
AllowCredentials: true,
|
|
ExposedHeaders: []string{"Authorization"},
|
|
AllowedMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"},
|
|
AllowedHeaders: []string{"Origin", "Content-Length", "Content-Type", "Authorization"},
|
|
MaxAge: 300,
|
|
}))
|
|
}
|
|
|
|
r.Group(func(r chi.Router) {
|
|
r.Use(
|
|
middleware.DataLoaderToContext(dataloader.Config{
|
|
ProfessionRepo: repos.professionRepository,
|
|
QualificationRepo: repos.qualificationRepository,
|
|
}),
|
|
middleware.Authenticate(ucases.authUsecase),
|
|
)
|
|
err := graphqlhttpdelivery.Attach(r, graphqlhttpdelivery.Config{
|
|
Resolver: &resolvers.Resolver{
|
|
AuthUsecase: ucases.authUsecase,
|
|
UserUsecase: ucases.userUsecase,
|
|
ProfessionUsecase: ucases.professionUsecase,
|
|
QualificationUsecase: ucases.qualificationUsecase,
|
|
QuestionUsecase: ucases.questionUsecase,
|
|
},
|
|
Directive: &directive.Directive{},
|
|
})
|
|
if err != nil {
|
|
log.Fatalln(err)
|
|
}
|
|
})
|
|
|
|
return r
|
|
}
|