fleets/grpcapi/grpcapi.go

212 lines
6.9 KiB
Go

package grpcapi
import (
context "context"
"fmt"
"log"
"net"
"git.coopgo.io/coopgo-platform/fleets/handlers"
"git.coopgo.io/coopgo-platform/fleets/storage"
"github.com/spf13/viper"
"google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
"google.golang.org/grpc/reflection"
status "google.golang.org/grpc/status"
)
type FleetsServerImpl struct {
handler handlers.FleetsHandler
}
func NewFleetsServer(h handlers.FleetsHandler) *FleetsServerImpl {
return &FleetsServerImpl{
handler: h,
}
}
func (s FleetsServerImpl) AddVehicle(ctx context.Context, req *AddVehicleRequest) (*AddVehicleResponse, error) {
v := req.Vehicle.ToStorageType()
vehicle, err := s.handler.AddVehicle(v)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.AlreadyExists, "vehicle creation failed : %v", err)
}
response, err := VehicleFromStorageType(vehicle)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.Internal, "issue while retrieving vehicle : %v", err)
}
return &AddVehicleResponse{Vehicle: response}, nil
}
func (s FleetsServerImpl) GetVehicle(ctx context.Context, req *GetVehicleRequest) (*GetVehicleResponse, error) {
vehicle, err := s.handler.GetVehicle(req.Vehicleid)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.AlreadyExists, "issue while retrieving vehicle : %v", err)
}
response, err := VehicleFromStorageType(vehicle)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.Internal, "issue while retrieving vehicle : %v", err)
}
return &GetVehicleResponse{Vehicle: response}, nil
}
func (s FleetsServerImpl) GetVehicles(ctx context.Context, req *GetVehiclesRequest) (*GetVehiclesResponse, error) {
filter := storage.VehicleFilters{
Types: req.Types,
Administrators: req.Administrators,
}
if req.AvailabilityFrom.IsValid() {
filter.AvailableFrom = req.AvailabilityFrom.AsTime()
}
if req.AvailabilityTo.IsValid() {
filter.AvailableTo = req.AvailabilityTo.AsTime()
}
responses, err := s.handler.GetVehicles(req.Namespaces, filter)
if err != nil {
return nil, status.Errorf(codes.NotFound, "could not get vehicles : %v", err)
}
var vehicles []*Vehicle
for _, v := range responses {
vehicle, err := VehicleFromStorageType(&v)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not get vehicle : %v", err)
}
vehicles = append(vehicles, vehicle)
}
return &GetVehiclesResponse{Vehicles: vehicles}, nil
}
func (s FleetsServerImpl) CreateBooking(ctx context.Context, req *CreateBookingRequest) (*CreateBookingResponse, error) {
b := req.Booking.ToStorageType()
booking, err := s.handler.AddBooking(b)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.AlreadyExists, "booking creation failed : %v", err)
}
response, err := BookingFromStorageType(booking)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.Internal, "issue while retrieving booking : %v", err)
}
return &CreateBookingResponse{Booking: response}, nil
}
func (s FleetsServerImpl) GetBooking(ctx context.Context, req *GetBookingRequest) (*GetBookingResponse, error) {
booking, err := s.handler.GetBooking(req.Bookingid)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.AlreadyExists, "issue while retrieving booking : %v", err)
}
response, err := BookingFromStorageType(booking)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.Internal, "issue while retrieving booking : %v", err)
}
return &GetBookingResponse{Booking: response}, nil
}
func (s FleetsServerImpl) UpdateBooking(ctx context.Context, req *UpdateBookingRequest) (*UpdateBookingResponse, error) {
b := req.Booking.ToStorageType()
booking, err := s.handler.UpdateBooking(b)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.AlreadyExists, "booking update failed : %v", err)
}
response, err := BookingFromStorageType(booking)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.Internal, "issue while retrieving booking : %v", err)
}
return &UpdateBookingResponse{Booking: response}, nil
}
func (s FleetsServerImpl) DeleteBooking(ctx context.Context, req *DeleteBookingRequest) (*DeleteBookingResponse, error) {
if err := s.handler.DeleteBooking(req.Id); err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.Internal, "issue while retrieving booking : %v", err)
}
return &DeleteBookingResponse{
Ok: true,
}, nil
}
func (s FleetsServerImpl) FindVehicle(context.Context, *FindVehicleRequest) (*FindVehicleResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method FindVehicle not implemented")
}
func (s FleetsServerImpl) GetDriverBookings(ctx context.Context, req *GetDriverBookingsRequest) (*GetDriverBookingsResponse, error) {
responses, err := s.handler.GetDriverBookings(req.Driver)
if err != nil {
return nil, status.Errorf(codes.NotFound, "could not get driver bookings : %v", err)
}
var bookings []*Booking
for _, b := range responses {
booking, err := BookingFromStorageType(&b)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not get booking : %v", err)
}
bookings = append(bookings, booking)
}
return &GetDriverBookingsResponse{Bookings: bookings}, nil
}
func (s FleetsServerImpl) GetBookings(ctx context.Context, req *GetBookingsRequest) (*GetBookingsResponse, error) {
responses, err := s.handler.GetBookings()
if err != nil {
return nil, status.Errorf(codes.NotFound, "could not get bookings : %v", err)
}
var bookings []*Booking
for _, b := range responses {
booking, err := BookingFromStorageType(&b)
if err != nil {
return nil, status.Errorf(codes.Internal, "could not get booking : %v", err)
}
bookings = append(bookings, booking)
}
return &GetBookingsResponse{Bookings: bookings}, nil
}
func (s FleetsServerImpl) mustEmbedUnimplementedFleetsServer() {}
func Run(done chan error, cfg *viper.Viper, handler handlers.FleetsHandler) {
var (
dev_env = cfg.GetBool("dev_env")
address = ":" + cfg.GetString("services.grpc.port")
)
fmt.Println("-> GRPC server on", address)
server := grpc.NewServer()
RegisterFleetsServer(server, NewFleetsServer(handler))
l, err := net.Listen("tcp", address)
if err != nil {
log.Fatal(err)
}
if dev_env {
reflection.Register(server)
}
if err := server.Serve(l); err != nil {
fmt.Println("gRPC service ended")
done <- err
}
}
/////////////////////update////////////////////////
func (s FleetsServerImpl) UpdateVehicle(ctx context.Context, req *UpdateVehicleRequest) (*UpdateVehicleResponse, error) {
b := req.Vehicle.ToStorageType()
vehicle, err := s.handler.UpdateVehicle(b)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.AlreadyExists, "vehicle update failed : %v", err)
}
response, err := VehicleFromStorageType(vehicle)
if err != nil {
fmt.Println(err)
return nil, status.Errorf(codes.Internal, "issue while retrieving vehicle : %v", err)
}
return &UpdateVehicleResponse{Vehicle: response}, nil
}