parcoursmob/services/services.go

package services

import (
	agenda "git.coopgo.io/coopgo-platform/agenda/grpcapi"
	carpoolservice "git.coopgo.io/coopgo-platform/carpool-service/servers/grpc/proto"
	diags "git.coopgo.io/coopgo-platform/diags/grpcapi"
	fleets "git.coopgo.io/coopgo-platform/fleets/grpcapi"
	"git.coopgo.io/coopgo-platform/geography/handlers/admin"
	groupsmanagement "git.coopgo.io/coopgo-platform/groups-management/grpcapi"
	mobilityaccounts "git.coopgo.io/coopgo-platform/mobility-accounts/grpcapi"
	multimodal "git.coopgo.io/coopgo-platform/multimodal-routing/handlers"
	"git.coopgo.io/coopgo-platform/multimodal-routing/libs/transit/motis"
	"git.coopgo.io/coopgo-platform/payments/pricing"
	"git.coopgo.io/coopgo-platform/routing-service"
	"git.coopgo.io/coopgo-platform/sms"
	solidaritytransport "git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen"
	"github.com/rs/zerolog/log"
	"github.com/spf13/viper"
)

type ServicesHandler struct {
	GRPC           GRPCServices
	InteropCarpool *multimodal.CarpoolRoutingHandler
	Routing        routing.RoutingService
	TransitRouting *motis.ClientWithResponses
	SMS            *sms.SMSHandler
	Pricing        pricing.PricingService
	Geography      admin.AdminIndex
}

type GRPCServices struct {
	MobilityAccounts    mobilityaccounts.MobilityAccountsClient
	GroupsManagement    groupsmanagement.GroupsManagementClient
	Fleets              fleets.FleetsClient
	Agenda              agenda.AgendaClient
	SolidarityTransport solidaritytransport.SolidarityTransportClient
	CarpoolService      carpoolservice.CarpoolServiceClient
	Diags               diags.DiagsClient
}

func NewServicesHandler(cfg *viper.Viper) (*ServicesHandler, error) {
	var (
		mobilityAccountsDial    = cfg.GetString("services.grpc.mobilityaccounts.dial")
		groupsManagementDial    = cfg.GetString("services.grpc.groupsmanagement.dial")
		fleetsDial              = cfg.GetString("services.grpc.fleets.dial")
		agendaDial              = cfg.GetString("services.grpc.agenda.dial")
		solidarityTransportDial = cfg.GetString("services.grpc.solidaritytransport.dial")
		carpoolServiceDial      = cfg.GetString("services.grpc.carpoolservice.dial")
		routing_service_type    = cfg.GetString("routing.type")
		valhalla_base_url       = cfg.GetString("routing.valhalla.base_url")

		// diagsDial            = cfg.GetString("services.grpc.diags.dial")
	)
	mobilityAccounts, err := NewMobilityAccountService(mobilityAccountsDial)
	if err != nil {
		log.Error().Err(err).Msg("Mobility Accounts service issue")
		return nil, err
	}

	groupsManagement, err := NewGroupsManagementService(groupsManagementDial)
	if err != nil {
		log.Error().Err(err).Msg("Groups mgmt service issue")
		return nil, err
	}

	fleetsSvc, err := NewFleetsService(fleetsDial)
	if err != nil {
		log.Error().Err(err).Msg("Fleets service issue")
		return nil, err
	}

	agendaSvc, err := NewAgendaService(agendaDial)
	if err != nil {
		log.Error().Err(err).Msg("Agenda service issue")
		return nil, err
	}

	solidarityTransportSvc, err := NewSolidarityTransportService(solidarityTransportDial)
	if err != nil {
		log.Error().Err(err).Msg("Solidarity Transport service issue")
		return nil, err
	}
	carpoolSvc, err := NewCarpoolService(carpoolServiceDial)
	if err != nil {
		log.Error().Err(err).Msg("Carpool service service issue")
		return nil, err
	}

	//diagsSvc, err := NewDiagsService(diagsDial)
	//	log.Error().Err(err).Msg("Mobility Accounts service issue")
	//if err != nil {
	//		return nil, err
	//}
	routing, err := routing.NewRoutingService(routing_service_type, valhalla_base_url)
	if err != nil {
		log.Fatal().Err(err).Msg("Could not initiate the routing service")
		return nil, err
	}

	carpoolRouting, err := multimodal.NewCarpoolRoutingHandler(cfg.Sub("multimodal.modes.carpool"))
	if err != nil {
		log.Fatal().Err(err).Msg("Could not initiate the carpool routing service")
		return nil, err
	}

	motisRouting, err := motis.NewClientWithResponses(cfg.GetString("multimodal.modes.transit.motis.server"))
	if err != nil {
		log.Fatal().Err(err).Msg("Could not initiate the transit routing service")
		return nil, err
	}

	pricing_type := cfg.GetString("payments.pricing.type")
	if pricing_type == "" {
		pricing_type = "mms43"
	}
	pricingService, err := pricing.NewPricingService(pricing_type)
	if err != nil {
		log.Fatal().Err(err).Msg("Could not initiate the pricing service")
		return nil, err
	}

	smsHandler, err := sms.NewSMSHandler(cfg.Sub("sms"))
	if err != nil {
		log.Fatal().Err(err).Msg("Could not initiate the SMS handler")
		return nil, err
	}

	geography, err := admin.NewAdminIndex(cfg.Sub("geography"))
	if err != nil {
		log.Fatal().Err(err).Msg("could not initiate admin index")
		return nil, err
	}

	return &ServicesHandler{
		GRPC: GRPCServices{
			MobilityAccounts:    mobilityAccounts,
			GroupsManagement:    groupsManagement,
			Fleets:              fleetsSvc,
			Agenda:              agendaSvc,
			SolidarityTransport: solidarityTransportSvc,
			CarpoolService:      carpoolSvc,
			//		Diags:            diagsSvc,
		},
		Routing:        routing,
		InteropCarpool: carpoolRouting,
		TransitRouting: motisRouting,
		SMS:            smsHandler,
		Pricing:        pricingService,
		Geography:      geography,
	}, nil
}