houston-be/appcontext/app.go

package appcontext

import (
	"github.com/slack-go/slack/socketmode"
	"github.com/spf13/viper"
	"gorm.io/gorm"
	"houston/model/incident"
	"houston/model/incident_products"
	"houston/model/log"
	productModel "houston/model/product"
	"houston/model/products_teams"
	"houston/model/severity"
	"houston/model/tag"
	"houston/model/team"
	"houston/model/user"
	conferenceActions "houston/pkg/conference"
	"houston/pkg/google/googleDrive"
	"houston/pkg/postgres"
	"houston/pkg/rest"
	"houston/repository/externalTeamRepo"
	rcaRepository "houston/repository/rca/impl"
	"houston/repository/rcaInput"
	teamSeverityRepo "houston/repository/teamSeverity"
	teamUserRepo "houston/repository/teamUser"
	teamUserSeverityRepo "houston/repository/teamUserSeverity"
	"houston/service/conference"
	"houston/service/documentService"
	"houston/service/google"
	incidentService "houston/service/incident/impl"
	"houston/service/incidentProducts"
	"houston/service/products"
	"houston/service/productsTeams"
	rcaService "houston/service/rca/impl"
	"houston/service/reminder"
	severityService "houston/service/severity"
	severityServiceImpl "houston/service/severity/impl"
	"houston/service/slack"
	tagService "houston/service/tag"
	"houston/service/teamService"
	"houston/service/teamSeverity"
	teamSeverityServiceImpl "houston/service/teamSeverity/impl"
	"houston/service/teamUser"
	teamUserServiceImpl "houston/service/teamUser/impl"
	"houston/service/teamUserSeverity"
	teamUserSeverityServiceImpl "houston/service/teamUserSeverity/impl"
	userService "houston/service/user"
)

type applicationContext struct {
	db *gorm.DB
}

// todo: all the repo objects to be cleaned uo from here. appContext will only have services
type houstonServices struct {
	logRepo                 *log.Repository
	teamRepo                *team.Repository
	severityRepo            *severity.Repository
	incidentRepo            *incident.Repository
	slackService            *slack.SlackService
	incidentService         *incidentService.IncidentServiceV2
	tagRepo                 *tag.Repository
	rcaRepository           *rcaRepository.Repository
	rcaInputRepository      *rcaInput.Repository
	userRepository          *user.Repository
	rcaService              *rcaService.RcaService
	driveService            google.IDriveService
	calendarService         *conference.CalendarService
	tagService              *tagService.TagService
	productsService         products.ProductService
	incidentProductsService incidentProducts.IncidentProductsService
	productTeamsService     productsTeams.ProductTeamsService
	severityService         severityService.ISeverityService
	teamSeverityService     teamSeverity.ITeamSeverityService
	userService             userService.UserService
	teamUserService         teamUser.ITeamUserService
	teamUserSeverityService teamUserSeverity.ITeamUserSeverityService
	teamService             teamService.ITeamServiceV2
	reminderService         reminder.ReminderService
}

var appContext *applicationContext
var services *houstonServices

func InitiateContext() {
	appContext = &applicationContext{
		db: initDB(),
	}
}

func InitializeServices() {
	logRepo := initLogRepo()
	severityRepo := initSeverityRepo()
	teamRepo := initTeamRepo(logRepo)
	slaService := initSlackService()
	services = &houstonServices{
		logRepo:                 logRepo,
		teamRepo:                teamRepo,
		severityRepo:            severityRepo,
		incidentRepo:            initIncidentRepo(severityRepo, logRepo, teamRepo, slaService.SocketModeClientWrapper.GetClient()),
		slackService:            slaService,
		incidentService:         initIncidentService(),
		tagRepo:                 initTagRepo(),
		rcaRepository:           initRCARepo(),
		rcaInputRepository:      initRCAInputRepo(),
		userRepository:          initUserRepo(),
		rcaService:              initRCAService(),
		driveService:            initDriveService(),
		calendarService:         initCalendarService(),
		tagService:              initTagService(),
		productsService:         initProductsService(),
		incidentProductsService: initIncidentProductsService(),
		productTeamsService:     initProductTeamsService(),
		severityService:         initSeverityService(),
		teamSeverityService:     initTeamSeverityService(),
		teamUserService:         initTeamUserService(),
		teamUserSeverityService: initTeamUserSeverityService(),
	}
	services.userService = initUserService()
	services.teamService = initTeamService()
	services.reminderService = initReminderService()
}

func initDB() *gorm.DB {
	return postgres.NewGormClient(
		viper.GetString("postgres.dsn"),
		viper.GetString("postgres.connection.max.idle.time"),
		viper.GetString("postgres.connection.max.lifetime"),
		viper.GetInt("postgres.connections.max.idle"),
		viper.GetInt("postgres.connections.max.open"),
	)
}

func GetDB() *gorm.DB {
	return appContext.db
}

func initLogRepo() *log.Repository {
	return log.NewLogRepository(GetDB())
}

func GetLogRepo() *log.Repository {
	return services.logRepo
}

func initTeamRepo(logRepo *log.Repository) *team.Repository {
	return team.NewTeamRepository(GetDB(), logRepo)
}

func GetTeamRepo() *team.Repository {
	return services.teamRepo
}

func initSeverityRepo() *severity.Repository {
	return severity.NewSeverityRepository(GetDB())
}

func GetSeverityRepo() *severity.Repository {
	return services.severityRepo
}

func initIncidentRepo(
	severityRepo *severity.Repository,
	logRepo *log.Repository,
	teamRepo *team.Repository,
	socketModeClient *socketmode.Client,
) *incident.Repository {
	return incident.NewIncidentRepository(GetDB(), severityRepo, logRepo, teamRepo, socketModeClient)
}

func GetIncidentRepo() *incident.Repository {
	return services.incidentRepo
}

func initSlackService() *slack.SlackService {
	return slack.NewSlackService()
}

func getRestClient() *rest.HttpRestClientImpl {
	return rest.NewHttpRestClient()
}

func initDocumentService() *documentService.ActionsImpl {
	return documentService.NewActionsImpl(getRestClient())
}

func initCalendarService() *conference.CalendarService {
	calendarActions := conferenceActions.GetCalendarActions()
	calendarService := conference.NewCalendarService(calendarActions)
	return calendarService
}

func initTeamService() teamService.ITeamServiceV2 {
	return teamService.NewTeamServiceV2(
		initTeamRepo(initLogRepo()),
		initUserRepo(),
		initSlackService(),
		externalTeamRepo.NewExternalTeamRepository(GetDB()),
		initTeamSeverityService(),
		initUserService(),
		initTeamUserService(),
		initTeamUserSeverityService(),
	)
}

func GetTeamService() teamService.ITeamServiceV2 {
	return services.teamService
}

func initTagService() *tagService.TagService {
	return tagService.NewTagService(GetDB())
}

func GetTagService() *tagService.TagService {
	return services.tagService
}

func initProductsService() products.ProductService {
	return products.NewProductService(productModel.NewProductRepo(GetDB()))
}

func GetProductsService() products.ProductService {
	return services.productsService
}

func initIncidentProductsService() incidentProducts.IncidentProductsService {
	return incidentProducts.NewIncidentProductsService(incident_products.NewIncidentProductsRepo(GetDB()))
}

func GetIncidentProductsService() incidentProducts.IncidentProductsService {
	return services.incidentProductsService
}

func initProductTeamsService() productsTeams.ProductTeamsService {
	return productsTeams.NewProductTeamsService(products_teams.NewProductsTeamsRepo(GetDB()))
}

func GetProductTeamsService() productsTeams.ProductTeamsService {
	return services.productTeamsService
}

func GetCalendarService() *conference.CalendarService {
	return services.calendarService
}

func GetDocumentService() *documentService.ActionsImpl {
	return initDocumentService()
}

func initRCAService() *rcaService.RcaService {
	rcaService := rcaService.NewRcaService(
		initIncidentService(), initSlackService(), initDocumentService(),
		initRCARepo(), initRCAInputRepo(), initUserRepo(), initDriveService(),
	)
	return rcaService
}

func GetSlackService() *slack.SlackService {
	return services.slackService
}

func initIncidentService() *incidentService.IncidentServiceV2 {
	return incidentService.NewIncidentServiceV2(GetDB())
}

func GetIncidentService() *incidentService.IncidentServiceV2 {
	if services.incidentService == nil {
		services.incidentService = initIncidentService()
	}
	return services.incidentService
}

func GetRCAService() *rcaService.RcaService {
	return services.rcaService
}
func initTagRepo() *tag.Repository {
	return tag.NewTagRepository(GetDB())
}

func GetTagRepo() *tag.Repository {
	return services.tagRepo
}

func initRCARepo() *rcaRepository.Repository {
	return rcaRepository.NewRcaRepository(GetDB())
}

func GetRCARepo() *rcaRepository.Repository {
	return services.rcaRepository
}

func initRCAInputRepo() *rcaInput.Repository {
	return rcaInput.NewRcaInputRepository(GetDB())
}

func GetRCAInputRepo() *rcaInput.Repository {
	return services.rcaInputRepository
}

func initUserRepo() *user.Repository {
	return user.NewUserRepository(GetDB())
}

func initSeverityService() severityService.ISeverityService {
	return severityServiceImpl.NewSeverityService(severity.NewSeverityRepository(GetDB()))
}

func GetSeverityService() severityService.ISeverityService {
	return services.severityService
}

func initTeamSeverityService() teamSeverity.ITeamSeverityService {
	return teamSeverityServiceImpl.NewTeamSeverityService(
		teamSeverityRepo.NewTeamSeverityRepository(GetDB()), initSeverityService(),
	)
}

func GetTeamSeverityService() teamSeverity.ITeamSeverityService {
	return services.teamSeverityService
}

func initUserService() userService.UserService {
	return userService.NewUserService(user.NewUserRepository(GetDB()), GetSlackService())
}

func GetUserService() userService.UserService {
	return services.userService
}

func initTeamUserService() teamUser.ITeamUserService {
	return teamUserServiceImpl.NewTeamUserService(teamUserRepo.NewTeamUserRepository(GetDB()))
}

func GetTeamUserService() teamUser.ITeamUserService {
	return services.teamUserService
}

func initTeamUserSeverityService() teamUserSeverity.ITeamUserSeverityService {
	return teamUserSeverityServiceImpl.NewTeamUserSeverityService(teamUserSeverityRepo.NewTeamUserSeverityRepository(GetDB()))
}

func GetTeamUserSeverityService() teamUserSeverity.ITeamUserSeverityService {
	return services.teamUserSeverityService
}

func initDriveService() google.IDriveService {
	driveAction, err := googleDrive.NewGoogleDriveActions()
	if err != nil {
		return nil
	}
	return google.NewDriveService(driveAction)
}

func GetDriveService() google.IDriveService {
	return services.driveService
}

func initReminderService() reminder.ReminderService {
	return reminder.NewReminderService(GetIncidentService(), GetTeamService(), GetSlackService(), GetSeverityService())
}

func GetReminderService() reminder.ReminderService {
	return services.reminderService
}