initial commit

2025-03-05 00:30:53 +01:00
commit 9da7b99e5d
32 changed files with 4541 additions and 0 deletions
--- a/servers/grpc/server/availabilities.go
+++ b/servers/grpc/server/availabilities.go
@@ -0,0 +1,74 @@
+package server
+
+import (
+	"context"
+
+	"git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen"
+	"git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers"
+	"git.coopgo.io/coopgo-platform/solidarity-transport/types"
+	"github.com/rs/zerolog/log"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (s SolidarityTransportServerImpl) AddDriverRegularAvailability(ctx context.Context, req *gen.AddDriverRegularAvailabilityRequest) (*gen.AddDriverRegularAvailabilityResponse, error) {
+	if err := s.Handler.AddRegularAvailability(req.DriverId, int(req.Day), req.StartTime, req.EndTime); err != nil {
+		return nil, status.Errorf(codes.Internal, "AddDriverRegularAvailability : %v", err)
+	}
+	return &gen.AddDriverRegularAvailabilityResponse{}, nil
+}
+
+func (s SolidarityTransportServerImpl) AddDriverRegularAvailabilities(ctx context.Context, req *gen.AddDriverRegularAvailabilitiesRequest) (*gen.AddDriverRegularAvailabilitiesResponse, error) {
+	log.Info().Msg("grpc call - AddDriverRegularAvailabilities")
+	availabilities := []*types.DriverRegularAvailability{}
+
+	for _, a := range req.Availabilities {
+		if a != nil {
+			log.Debug().Any("availability", a).Msg("New availability")
+			na := transformers.DriverRegularAvailabilityProtoToType(a)
+			availabilities = append(availabilities, na)
+		}
+	}
+	if err := s.Handler.AddDriverRegularAvailabilities(availabilities); err != nil {
+		log.Error().Err(err).Msg("AddDriverAvailabilities error")
+		return nil, status.Errorf(codes.Internal, "AddDriverRegularAvailabilities : %v", err)
+	}
+	return &gen.AddDriverRegularAvailabilitiesResponse{}, nil
+}
+
+func (s SolidarityTransportServerImpl) GetDriverRegularAvailabilities(ctx context.Context, req *gen.GetDriverRegularAvailabilitiesRequest) (*gen.GetDriverRegularAvailabilitiesResponse, error) {
+	log.Info().Str("driver", req.DriverId).Msg("grpc call - GetDriverRegularAvailabilities")
+	availabilities, err := s.Handler.GetDriverRegularAvailabilities(req.DriverId)
+	if err != nil {
+		log.Error().Err(err).Msg("GetDriverRegularAvailabilities error")
+		return nil, status.Errorf(codes.Internal, "GetDriverRegularAvailabilities : %v", err)
+	}
+
+	results := []*gen.DriverRegularAvailability{}
+
+	log.Debug().Any("availabilities", availabilities).Msg("retrieved availabilities")
+
+	for _, a := range availabilities {
+		if a != nil {
+			log.Debug().Any("availability", a).Msg("Availability")
+			protoavailability := transformers.DriverRegularAvailabilityTypeToProto(a)
+			results = append(results, protoavailability)
+		}
+	}
+
+	return &gen.GetDriverRegularAvailabilitiesResponse{
+		Results: results,
+	}, nil
+}
+
+func (s SolidarityTransportServerImpl) DeleteDriverRegularAvailability(ctx context.Context, req *gen.DeleteDriverRegularAvailabilityRequest) (*gen.DeleteDriverRegularAvailabilityResponse, error) {
+	driverid := req.DriverId
+	availabilityid := req.AvailabilityId
+
+	if err := s.Handler.DeleteDriverRegularAvailabilities(driverid, availabilityid); err != nil {
+		log.Error().Err(err).Msg("DeleteDriverRegularAvailability error")
+		return nil, status.Errorf(codes.Internal, "DeleteDriverRegularAvailability error : %v", err)
+	}
+
+	return &gen.DeleteDriverRegularAvailabilityResponse{}, nil
+}
--- a/servers/grpc/server/bookings.go
+++ b/servers/grpc/server/bookings.go
@@ -0,0 +1,76 @@
+package server
+
+import (
+	"context"
+
+	"git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen"
+	"git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers"
+	"github.com/rs/zerolog/log"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (s SolidarityTransportServerImpl) BookDriverJourney(ctx context.Context, req *gen.BookDriverJourneyRequest) (*gen.BookDriverJourneyResponse, error) {
+	passengerId := req.PassengerId
+	driverId := req.DriverId
+	journeyId := req.DriverJourneyId
+
+	if err := s.Handler.BookDriverJourney(passengerId, driverId, journeyId); err != nil {
+		log.Error().Err(err).Msg("issue in BookDriverJourney handler")
+		return nil, status.Errorf(codes.Internal, "could not create booking : %v", err)
+	}
+	return &gen.BookDriverJourneyResponse{}, nil
+}
+
+func (s SolidarityTransportServerImpl) GetSolidarityTransportBookings(ctx context.Context, req *gen.GetSolidarityTransportBookingsRequest) (*gen.GetSolidarityTransportBookingsResponse, error) {
+	startdate := req.StartDate.AsTime()
+	enddate := req.EndDate.AsTime()
+	bookings, err := s.Handler.GetBookings(startdate, enddate)
+	if err != nil {
+		log.Error().Err(err).Msg("issue in GetBookings handler")
+		return nil, status.Errorf(codes.NotFound, "could not get bookings : %v", err)
+	}
+
+	protobookings := []*gen.SolidarityTransportBooking{}
+	for _, b := range bookings {
+		protobooking, _ := transformers.BookingTypeToProto(b)
+		protobookings = append(protobookings, protobooking)
+	}
+
+	return &gen.GetSolidarityTransportBookingsResponse{
+		Bookings: protobookings,
+	}, nil
+}
+
+func (s SolidarityTransportServerImpl) GetSolidarityTransportBooking(ctx context.Context, req *gen.GetSolidarityTransportBookingRequest) (*gen.GetSolidarityTransportBookingResponse, error) {
+	bookingid := req.Id
+
+	booking, err := s.Handler.GetBooking(bookingid)
+	if err != nil {
+		log.Error().Err(err).Msg("issue in GetBooking handler")
+		return nil, status.Errorf(codes.NotFound, "could not get booking : %v", err)
+	}
+
+	bookingproto, err := transformers.BookingTypeToProto(booking)
+	if err != nil {
+		log.Error().Err(err).Msg("issue in GetBooking handler")
+		return nil, status.Errorf(codes.NotFound, "transformer issue on booking : %v", err)
+	}
+
+	return &gen.GetSolidarityTransportBookingResponse{
+		Booking: bookingproto,
+	}, nil
+}
+
+func (s SolidarityTransportServerImpl) UpdateSolidarityTransportBookingStatus(ctx context.Context, req *gen.UpdateSolidarityTransportBookingStatusRequest) (*gen.UpdateSolidarityTransportBookingStatusResponse, error) {
+	bookingid := req.BookingId
+	newStatus := req.NewStatus
+
+	err := s.Handler.UpdateBookingStatus(bookingid, newStatus)
+	if err != nil {
+		log.Error().Err(err).Msg("issue in GetBooking handler")
+		return nil, status.Errorf(codes.NotFound, "transformer issue on booking : %v", err)
+	}
+
+	return &gen.UpdateSolidarityTransportBookingStatusResponse{}, nil
+}
--- a/servers/grpc/server/journeys.go
+++ b/servers/grpc/server/journeys.go
@@ -0,0 +1,67 @@
+package server
+
+import (
+	"context"
+
+	"git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen"
+	"git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/transformers"
+	"github.com/paulmach/orb/geojson"
+	"github.com/rs/zerolog/log"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (s SolidarityTransportServerImpl) GetDriverJourneys(ctx context.Context, req *gen.GetDriverJourneysRequest) (*gen.GetDriverJourneysResponse, error) {
+	departureDate := req.DepartureDate.AsTime()
+	departure, err := geojson.UnmarshalFeature([]byte(req.Departure.Serialized))
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "departure unmarshalling error: %v", err)
+	}
+	arrival, err := geojson.UnmarshalFeature([]byte(req.Arrival.Serialized))
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "arrival unmarhsalling error : %v", err)
+	}
+
+	driverJourneys, err := s.Handler.GetDriverJourneys(departure, arrival, departureDate)
+	if err != nil {
+		log.Error().Err(err).Msg("issue in GetDriverJourneys handler")
+		return nil, status.Errorf(codes.Internal, "could not get driver journeys : %v", err)
+	}
+
+	results := []*gen.SolidarityTransportDriverJourney{}
+
+	for _, j := range driverJourneys {
+		// transformer
+		dj, err := transformers.DriverJourneyTypeToProto(j)
+		if err != nil {
+			log.Error().Err(err).Msg("issue while converting DriverJourney type to protobuf")
+			continue
+			// return nil, status.Errorf(codes.Internal, "could not get driver journeys : %v", err)
+		}
+		results = append(results, dj)
+	}
+
+	return &gen.GetDriverJourneysResponse{
+		DriverJourneys: results,
+	}, nil
+}
+
+func (s SolidarityTransportServerImpl) GetDriverJourney(ctx context.Context, req *gen.GetDriverJourneyRequest) (*gen.GetDriverJourneyResponse, error) {
+	driverid := req.DriverId
+	journeyid := req.JourneyId
+
+	journey, err := s.Handler.GetDriverJourney(driverid, journeyid)
+	if err != nil {
+		return nil, status.Errorf(codes.NotFound, "could not get driver journey : %v", err)
+	}
+
+	protojourney, err := transformers.DriverJourneyTypeToProto(journey)
+	if err != nil {
+		log.Error().Err(err).Msg("transformation error")
+		return nil, status.Errorf(codes.NotFound, "transformation error : %v", err)
+	}
+
+	return &gen.GetDriverJourneyResponse{
+		DriverJourney: protojourney,
+	}, nil
+}
--- a/servers/grpc/server/server.go
+++ b/servers/grpc/server/server.go
@@ -0,0 +1,50 @@
+package server
+
+import (
+	"fmt"
+	"net"
+
+	"git.coopgo.io/coopgo-platform/solidarity-transport/handler"
+	"git.coopgo.io/coopgo-platform/solidarity-transport/servers/grpc/proto/gen"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+type SolidarityTransportServerImpl struct {
+	Handler *handler.Handler
+
+	gen.UnimplementedSolidarityTransportServer
+}
+
+func NewSolidarityTransportServer(handler *handler.Handler) *SolidarityTransportServerImpl {
+	return &SolidarityTransportServerImpl{
+		Handler: handler,
+	}
+}
+
+func Run(done chan error, cfg *viper.Viper, handler *handler.Handler) {
+	var (
+		dev_env = cfg.GetBool("dev_env")
+		address = ":" + cfg.GetString("services.grpc.port")
+	)
+
+	server := grpc.NewServer()
+
+	gen.RegisterSolidarityTransportServer(server, NewSolidarityTransportServer(handler))
+	l, err := net.Listen("tcp", address)
+	if err != nil {
+		log.Fatal().Err(err).Msg("could not register solidarity transport grpc server")
+		return
+	}
+
+	if dev_env {
+		reflection.Register(server)
+	}
+
+	if err := server.Serve(l); err != nil {
+		fmt.Println("gRPC service ended")
+		done <- err
+	}
+}