refactoring

2023-12-08 07:31:41 +01:00
parent d12c55d740
commit 150c913feb
19 changed files with 1175 additions and 814 deletions
--- a/storage/postgresql.go
+++ b/storage/postgresql.go
@@ -15,6 +15,7 @@ import (
 	"solidarity-service/utils"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )

@@ -66,11 +67,7 @@ func (s PostgresqlStorage) CreatePassenger(passenger internal.Passenger) (err er
 		log.Error().Err(err).Msg("Postgresql Storage CreatePassenger invalid ID")
 		return err
 	}
-	if passenger.Passenger_pickup_date == 0 {
-		errMsg := "Postgresql Storage CreatePassenger empty UNIX pickup Date timestamp"
-		log.Error().Err(err).Msg(errMsg)
-		return errors.New(errMsg)
-	}
+
 	if passenger.Passenger.Alias == "" || passenger.Passenger.Operator == "" {
 		errMsg := "Postgresql Storage CreatePassenger empty alias or operator FQDN."
 		log.Error().Msg(errMsg)
@@ -82,23 +79,8 @@ func (s PostgresqlStorage) CreatePassenger(passenger internal.Passenger) (err er
 		log.Error().Err(err).Msg(errMsg)
 		return errors.New(errMsg + err.Error())
 	}
-	departureJSON, err := json.Marshal(passenger.Passenger_departure_address)
-	if err != nil {
-		errMsg := "Postgresql Storage CreatePassenger Error encoding departure Feature to JSON"
-		log.Error().Err(err).Msg(errMsg)
-		return errors.New(errMsg + err.Error())
-	}
-
-	destinationJSON, err := json.Marshal(passenger.Passenger_destination_address)
-	if err != nil {
-		errMsg := "Postgresql Storage CreatePassenger Error converting destination Feature to JSON"
-		log.Error().Err(err).Msg(errMsg)
-		return errors.New(errMsg + err.Error())
-	}
-	_, err = s.DbConnection.Exec(fmt.Sprintf("INSERT INTO %s (passenger_id, passenger_departure_route, passenger_destination_route, alias, last_name, first_name, grade, picture, verified_identity, operator, preferences, passenger_pickup_date) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12)", s.Tables["passengers"]),
+	_, err = s.DbConnection.Exec(fmt.Sprintf("INSERT INTO %s (passenger_id, alias, last_name, first_name, grade, picture, verified_identity, operator, preferences) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)", s.Tables["passengers"]),
 		passenger.Passenger.ID,
-		departureJSON,
-		destinationJSON,
 		passenger.Passenger.Alias,
 		passenger.Passenger.LastName,
 		passenger.Passenger.FirstName,
@@ -106,24 +88,72 @@ func (s PostgresqlStorage) CreatePassenger(passenger internal.Passenger) (err er
 		passenger.Passenger.Picture,
 		passenger.Passenger.VerifiedIdentity,
 		passenger.Passenger.Operator,
-		preferencesJSON,
-		passenger.Passenger_pickup_date)
+		preferencesJSON)
 	if err != nil {
+		if strings.Contains(err.Error(), utils.SQL_DUPLICATE) {
+			err = s.UpdatePassenger(passenger)
+			if err != nil {
+				return err
+			}
+			return nil
+		}
 		errMsg := "Postgresql Storage CreatePassenger Error inserting data into the database"
 		log.Error().Err(err).Msg(errMsg)
 		return errors.New(errMsg + err.Error())
 	}
 	return nil
 }
+func (s PostgresqlStorage) UpdatePassenger(passenger internal.Passenger) (err error) {
+	_, err = uuid.Parse(passenger.Passenger.ID)
+	if err != nil {
+		log.Error().Err(err).Msg("Postgresql Storage UpdatePassenger invalid ID")
+		return err
+	}
+	if passenger.Passenger.Alias == "" || passenger.Passenger.Operator == "" {
+		errMsg := "Postgresql Storage UpdatePassenger empty alias or operator FQDN."
+		log.Error().Msg(errMsg)
+		return errors.New(errMsg)
+	}
+	preferencesJSON, err := json.Marshal(passenger.Preferences)
+	if err != nil {
+		errMsg := "Postgresql Storage UpdatePassenger Error encoding Preferences to JSON"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg + err.Error())
+	}
+	_, err = s.DbConnection.Exec(fmt.Sprintf(`
+		UPDATE %s
+		SET
+			alias = $2,
+			last_name = $3,
+			first_name = $4,
+			grade = $5,
+			picture = $6,
+			verified_identity = $7,
+			operator = $8,
+			preferences = $9
+		WHERE passenger_id = $1
+	`, s.Tables["passengers"]),
+		passenger.Passenger.ID,
+		passenger.Passenger.Alias,
+		passenger.Passenger.LastName,
+		passenger.Passenger.FirstName,
+		passenger.Passenger.Grade,
+		passenger.Passenger.Picture,
+		passenger.Passenger.VerifiedIdentity,
+		passenger.Passenger.Operator,
+		preferencesJSON)
+	if err != nil {
+		errMsg := "Postgresql Storage UpdatePassenger Error updating data in the database"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg + err.Error())
+	}
+	return nil
+}

 func (s PostgresqlStorage) GetPassenger(passengerID string) (passenger internal.Passenger, err error) {
 	var preferencesJSON []byte
-	var departure_address []byte
-	var destination_address []byte
-	err = s.DbConnection.QueryRow(fmt.Sprintf("SELECT passenger_departure_route, passenger_destination_route, alias, last_name, first_name, grade, picture, verified_identity, operator, preferences, passenger_pickup_date , passenger_id FROM %s WHERE passenger_id = $1", s.Tables["passengers"]), passengerID).
+	err = s.DbConnection.QueryRow(fmt.Sprintf("SELECT alias, last_name, first_name, grade, picture, verified_identity, operator, preferences, passenger_id FROM %s WHERE passenger_id = $1", s.Tables["passengers"]), passengerID).
 		Scan(
-			&departure_address,
-			&destination_address,
 			&passenger.Passenger.Alias,
 			&passenger.Passenger.LastName,
 			&passenger.Passenger.FirstName,
@@ -132,11 +162,9 @@ func (s PostgresqlStorage) GetPassenger(passengerID string) (passenger internal.
 			&passenger.Passenger.VerifiedIdentity,
 			&passenger.Passenger.Operator,
 			&preferencesJSON,
-			&passenger.Passenger_pickup_date,
 			&passenger.Passenger.ID,
 		)
 	if err != nil {
-		fmt.Println(err)
 		errMsg := "Postgresql Storage GetPassenger Error querying data from the database"
 		log.Error().Err(err).Msg(errMsg)
 		return passenger, errors.New(errMsg + err.Error())
@@ -148,18 +176,6 @@ func (s PostgresqlStorage) GetPassenger(passengerID string) (passenger internal.
 		log.Error().Err(err).Msg(errMsg)
 		return passenger, errors.New(errMsg + err.Error())
 	}
-	passenger.Passenger_destination_address, err = geojson.UnmarshalFeature(destination_address)
-	if err != nil {
-		errMsg := "Postgresql Storage GetPassenger Error decoding Passenger destination route into GeoJSON"
-		log.Error().Err(err).Msg(errMsg)
-		return passenger, errors.New(errMsg + err.Error())
-	}
-	passenger.Passenger_departure_address, err = geojson.UnmarshalFeature(departure_address)
-	if err != nil {
-		errMsg := "Postgresql Storage GetPassenger Error decoding Passenger departure route into GeoJSON"
-		log.Error().Err(err).Msg(errMsg)
-		return passenger, errors.New(errMsg + err.Error())
-	}
 	return passenger, nil
 }

@@ -236,13 +252,116 @@ func (s PostgresqlStorage) CreateDriver(driver internal.Driver) (err error) {
 		carJSON,
 	)
 	if err != nil {
-		fmt.Println(err)
+		if strings.Contains(err.Error(), utils.SQL_DUPLICATE) {
+			err = s.UpdateDriver(driver)
+			if err != nil {
+				return err
+			}
+			return nil
+		}
 		errMsg := "Postgresql Storage CreateDriver Error inserting data into the database"
 		log.Error().Err(err).Msg(errMsg)
 		return errors.New(errMsg + err.Error())
 	}
 	return nil
 }
+func (s PostgresqlStorage) UpdateDriver(driver internal.Driver) (err error) {
+	var availabilities []byte
+	_, err = uuid.Parse(driver.Driver.ID)
+	if err != nil {
+		log.Error().Err(err).Msg("Postgresql Storage UpdateDriver invalid ID")
+		return err
+	}
+	departureJSON, err := json.Marshal(driver.Driver_departure_address)
+	if err != nil {
+		errMsg := "Postgresql Storage UpdateDriver Error encoding departure Feature to JSON"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg + err.Error())
+	}
+	preferencesJSON, err := json.Marshal(driver.Preferences)
+	if err != nil {
+		errMsg := "Postgresql Storage UpdateDriver Error encoding Preferences to JSON"
+		log.Error().Err(err).Msg(errMsg + err.Error())
+		return errors.New(errMsg)
+	}
+	carJSON, err := json.Marshal(driver.Car)
+	if err != nil {
+		errMsg := "Postgresql Storage UpdateDriver Error encoding Car to JSON"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg + err.Error())
+	}
+	if driver.Driver.Alias == "" || driver.Driver.Operator == "" {
+		errMsg := "Postgresql Storage UpdateDriver empty alias or operator FQDN."
+		log.Error().Msg(errMsg)
+		return errors.New(errMsg)
+	}
+	if driver.AvailabilitiesType != internal.Punctual && driver.AvailabilitiesType != internal.Regular {
+		errMsg := "Postgresql Storage UpdateDriver invalid Availabilities Type"
+		log.Error().Msg(errMsg)
+		return errors.New(errMsg)
+	}
+	if driver.Radius == 0 {
+		errMsg := "Postgresql Storage UpdateDriver Radius has to be defined"
+		log.Error().Msg(errMsg)
+		return errors.New(errMsg)
+	}
+	switch driver.AvailabilitiesType {
+	case internal.Punctual:
+		availabilities, err = json.Marshal(driver.PunctualAvailabilities)
+		if err != nil {
+			errMsg := "Postgresql Storage UpdateDriver error converting Punctual availabilities"
+			log.Error().Msg(errMsg)
+			return errors.New(errMsg + err.Error())
+		}
+	case internal.Regular:
+		availabilities, err = json.Marshal(driver.RegularAvailabilities)
+		if err != nil {
+			errMsg := "Postgresql Storage UpdateDriver error converting Regular availabilities"
+			log.Error().Msg(errMsg)
+			return errors.New(errMsg + err.Error())
+		}
+	}
+
+	_, err = s.DbConnection.Exec(fmt.Sprintf(`
+		UPDATE %s
+		SET
+			driver_departure_route = $2,
+			driver_radius = $3,
+			last_name = $4,
+			first_name = $5,
+			grade = $6,
+			alias = $7,
+			picture = $8,
+			verified_identity = $9,
+			preferences = $10,
+			availabilities_type = $11,
+			availabilities = $12,
+			operator = $13,
+			car = $14
+		WHERE driver_id = $1
+	`, s.Tables["drivers"]),
+		driver.Driver.ID,
+		departureJSON,
+		driver.Radius,
+		driver.Driver.LastName,
+		driver.Driver.FirstName,
+		driver.Driver.Grade,
+		driver.Driver.Alias,
+		driver.Driver.Picture,
+		driver.Driver.VerifiedIdentity,
+		preferencesJSON,
+		driver.AvailabilitiesType,
+		string(availabilities),
+		driver.Driver.Operator,
+		carJSON,
+	)
+	if err != nil {
+		errMsg := "Postgresql Storage UpdateDriver Error updating data in the database"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg + err.Error())
+	}
+	return nil
+}

 func (s PostgresqlStorage) GetDriver(driverID string) (driver internal.Driver, err error) {
 	var preferencesJSON []byte
@@ -335,12 +454,38 @@ func (s PostgresqlStorage) CreateBooking(booking internal.BookingRequest) (err e
 		log.Error().Err(err).Msg("Postgresql Storage CreateBooking empty operator")
 		return err
 	}
-	_, err = s.DbConnection.Exec(fmt.Sprintf("INSERT INTO %s (booking_id , passenger_id , driver_id , operator, booking_status) VALUES ($1,$2,$3,$4,$5)", s.Tables["bookings"]),
+	departureJSON, err := json.Marshal(booking.Departure_address)
+	if err != nil {
+		errMsg := "Postgresql Storage CreateBooking Error encoding departure Feature to JSON"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg + err.Error())
+	}
+
+	destinationJSON, err := json.Marshal(booking.Destination_address)
+	if err != nil {
+		errMsg := "Postgresql Storage CreateBooking Error converting destination Feature to JSON"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg + err.Error())
+	}
+	if booking.Pickup_date == 0 {
+		errMsg := "Postgresql Storage CreateBooking empty UNIX pickup Date timestamp"
+		log.Error().Err(err).Msg(errMsg)
+		return errors.New(errMsg)
+	}
+	booking.Distance = utils.Haversine(booking.Departure_address.Point().Lat(), booking.Departure_address.Point().Lon(),
+		booking.Destination_address.Point().Lat(), booking.Destination_address.Point().Lon())
+	booking.Duration, _ = utils.CalculateDurationBetweenFeatures(booking.Departure_address, booking.Destination_address)
+	_, err = s.DbConnection.Exec(fmt.Sprintf("INSERT INTO %s (booking_id , passenger_id , driver_id , operator, booking_status,departure_address,destination_address,pickup_date,duration,distance) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10)", s.Tables["bookings"]),
 		booking.ID,
 		booking.Passenger_id,
 		booking.Driver_id,
 		booking.Operator,
 		booking.Status,
+		departureJSON,
+		destinationJSON,
+		booking.Pickup_date,
+		booking.Duration,
+		booking.Distance,
 	)
 	if err != nil {
 		errMsg := "Postgresql Storage CreateBooking Error inserting data into the database"
@@ -351,18 +496,37 @@ func (s PostgresqlStorage) CreateBooking(booking internal.BookingRequest) (err e
 }

 func (s PostgresqlStorage) GetBooking(id string) (booking internal.Booking, err error) {
-	err = s.DbConnection.QueryRow(fmt.Sprintf("SELECT booking_id , passenger_id , driver_id ,  booking_status FROM %s WHERE booking_id = $1", s.Tables["bookings"]), id).
+	var departureAddress []byte
+	var destinationAddress []byte
+	err = s.DbConnection.QueryRow(fmt.Sprintf("SELECT booking_id , passenger_id , driver_id ,  booking_status , departure_address,destination_address,pickup_date,duration,distance FROM %s WHERE booking_id = $1", s.Tables["bookings"]), id).
 		Scan(
 			&booking.ID,
 			&booking.Passenger.ID,
 			&booking.Driver.ID,
 			&booking.Status,
+			&departureAddress,
+			&destinationAddress,
+			&booking.Pickup_date,
+			&booking.Duration,
+			&booking.Distance,
 		)

 	if err != nil {
 		errMsg := "Postgresql Storage GetBooking Error getting booking"
 		log.Error().Err(err).Msg(errMsg)
-		return booking, errors.New(errMsg + err.Error())
+		return internal.Booking{}, errors.New(errMsg + err.Error())
+	}
+	booking.PassengerPickupAddress, err = geojson.UnmarshalFeature(departureAddress)
+	if err != nil {
+		errMsg := "Postgresql Storage GetBooking Error decoding Driver departure route into GeoJSON"
+		log.Error().Err(err).Msg(errMsg)
+		return internal.Booking{}, errors.New(errMsg + err.Error())
+	}
+	booking.PassengerDropAddress, err = geojson.UnmarshalFeature(destinationAddress)
+	if err != nil {
+		errMsg := "Postgresql Storage GetBooking Error decoding Driver destination route into GeoJSON"
+		log.Error().Err(err).Msg(errMsg)
+		return internal.Booking{}, errors.New(errMsg + err.Error())
 	}
 	passenger, err := s.GetPassenger(booking.Passenger.ID)
 	if err != nil {
@@ -371,8 +535,6 @@ func (s PostgresqlStorage) GetBooking(id string) (booking internal.Booking, err
 		return booking, errors.New(errMsg + err.Error())
 	}
 	booking.Passenger = passenger.Passenger
-	booking.PassengerPickupAddress = passenger.Passenger_departure_address
-	booking.PassengerDropAddress = passenger.Passenger_destination_address
 	driver, err := s.GetDriver(booking.Driver.ID)
 	if err != nil {
 		errMsg := "Postgresql Storage GetBooking Error getting driver"
@@ -404,55 +566,147 @@ func (s PostgresqlStorage) UpdateBookingStatus(id string, status internal.Bookin
 	return nil
 }

-func (s PostgresqlStorage) FilterUserBookingsByStatus(user_type string, status internal.BookingStatus, user_id string) (bookings []internal.Booking, err error) {
-	_, err = uuid.Parse(user_id)
+func (s PostgresqlStorage) FilterUserBookingsByStatus(userType string, status internal.BookingStatus, userID string) (bookings []internal.Booking, err error) {
 	if err != nil {
-		return nil, errors.New("invalid uuid")
+		return nil, errors.New("invalid UUID")
 	}

-	if user_type != "driver" && user_type != "passenger" {
+	if userType != "driver" && userType != "passenger" {
 		return nil, errors.New("invalid user type")
 	}
-	switch user_type {
-	case "driver":
-		rows, err := s.DbConnection.Query(fmt.Sprintf("SELECT booking_id, passenger_id, driver_id, booking_status FROM %s WHERE driver_id = $1 AND booking_status = $2", s.Tables["bookings"]),
-			user_id, status)
-		if err != nil {
-			return nil, err
-		}
-		defer rows.Close()
-		for rows.Next() {
-			var booking internal.Booking
-			if err := rows.Scan(&booking.ID, &booking.Passenger.ID, &booking.Driver.ID, &booking.Status); err != nil {
-				return nil, err
-			}
-			bookings = append(bookings, booking)
-		}
-		if err := rows.Err(); err != nil {
-			return nil, err
-		}
-	case "passenger":
-		rows, err := s.DbConnection.Query(fmt.Sprintf("SELECT booking_id, passenger_id, driver_id, booking_status FROM %s WHERE passenger_id = $1 AND booking_status = $2", s.Tables["bookings"]),
-			user_id, status)
-		if err != nil {
-			return nil, err
-		}
-		defer rows.Close()
-		for rows.Next() {
-			var booking internal.Booking
-			if err := rows.Scan(&booking.ID, &booking.Passenger.ID, &booking.Driver.ID, &booking.Status); err != nil {
-				return nil, err
-			}
-			bookings = append(bookings, booking)
-		}
-		if err := rows.Err(); err != nil {
+
+	queryTemplate := fmt.Sprintf("SELECT booking_id, passenger_id, driver_id, booking_status, departure_address, destination_address, pickup_date,duration,distance FROM %s WHERE %s_id = $1 AND booking_status = $2", s.Tables["bookings"], userType)
+
+	rows, err := s.DbConnection.Query(queryTemplate, userID, status)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+
+	for rows.Next() {
+		var departureAddress []byte
+		var destinationAddress []byte
+		var booking internal.Booking
+
+		if err := rows.Scan(&booking.ID, &booking.Passenger.ID, &booking.Driver.ID, &booking.Status, &departureAddress, &destinationAddress, &booking.Pickup_date, &booking.Duration, &booking.Distance); err != nil {
 			return nil, err
 		}

+		wg.Add(1)
+		go func(booking internal.Booking, departureAddress, destinationAddress []byte) {
+			defer wg.Done()
+
+			// Common logic for both "driver" and "passenger" cases
+			booking, err := s.populateBookingDetails(booking, departureAddress, destinationAddress)
+			if err != nil {
+				mu.Lock()
+				err = fmt.Errorf("Error populating booking details: %w", err)
+				mu.Unlock()
+				return
+			}
+
+			mu.Lock()
+			bookings = append(bookings, booking)
+			mu.Unlock()
+		}(booking, departureAddress, destinationAddress)
 	}
+
+	// Wait for all goroutines to finish
+	wg.Wait()
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
 	return bookings, nil
 }

+func (s PostgresqlStorage) populateBookingDetails(booking internal.Booking, departureAddress, destinationAddress []byte) (internal.Booking, error) {
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	errCh := make(chan error, 4) // Buffered channel to handle potential errors
+
+	// Concurrently fetch passenger information
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		passenger, err := s.GetPassenger(booking.Passenger.ID)
+		if err != nil {
+			errCh <- fmt.Errorf("Postgresql Storage GetBooking Error getting passenger: %w", err)
+			return
+		}
+
+		mu.Lock()
+		booking.Passenger = passenger.Passenger
+		mu.Unlock()
+	}()
+
+	// Concurrently fetch driver information
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		driver, err := s.GetDriver(booking.Driver.ID)
+		if err != nil {
+			errCh <- fmt.Errorf("Postgresql Storage GetBooking Error getting driver: %w", err)
+			return
+		}
+
+		mu.Lock()
+		booking.Driver = driver.Driver
+		mu.Unlock()
+	}()
+
+	// Concurrently decode departureAddress into GeoJSON
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		decodedDepartureAddress, err := geojson.UnmarshalFeature(departureAddress)
+		if err != nil {
+			errCh <- fmt.Errorf("Postgresql Storage FilterBookingsByStatus Error decoding Driver departure route into GeoJSON: %w", err)
+			return
+		}
+
+		mu.Lock()
+		booking.PassengerPickupAddress = decodedDepartureAddress
+		mu.Unlock()
+	}()
+
+	// Concurrently decode destinationAddress into GeoJSON
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+
+		decodedDestinationAddress, err := geojson.UnmarshalFeature(destinationAddress)
+		if err != nil {
+			errCh <- fmt.Errorf("Postgresql Storage FilterBookingsByStatus Error decoding Driver destination route into GeoJSON: %w", err)
+			return
+		}
+
+		mu.Lock()
+		booking.PassengerDropAddress = decodedDestinationAddress
+		mu.Unlock()
+	}()
+
+	// Close the error channel after all goroutines are done
+	go func() {
+		wg.Wait()
+		close(errCh)
+	}()
+
+	// Check for errors using a select statement
+	for err := range errCh {
+		return internal.Booking{}, err // Return the first error encountered
+	}
+
+	return booking, nil
+}
+
 func (s PostgresqlStorage) GetAllDrivers(date int64) (drivers []internal.Driver, err error) {
 	rows, err := s.DbConnection.Query(fmt.Sprintf("SELECT driver_id, driver_departure_route, driver_radius, last_name, first_name, grade, alias, picture, verified_identity, preferences, availabilities_type, availabilities, operator, car FROM %s", s.Tables["drivers"]))
 	if err != nil {
@@ -496,34 +750,76 @@ func (s PostgresqlStorage) GetAllDrivers(date int64) (drivers []internal.Driver,
 			return nil, err
 		}

-		// Filter drivers based on date matching punctual or regular availabilities.
+		// Filter drivers based on date and time matching punctual or regular availabilities.
 		if driver.AvailabilitiesType == internal.Punctual {
 			if err := json.Unmarshal(availabilitiesJSON, &driver.PunctualAvailabilities); err != nil {
 				return nil, err
 			}
-			// Convert the date to the day of the week and make it lowercase.
-			dayOfWeek := strings.ToLower(time.Unix(date, 0).UTC().Format("Mon"))
-
+			year, month, day := time.Unix(date, 0).Date()
+			dateHour := time.Unix(date, 0).UTC().Local()
+			dateHour_string := dateHour.Format("3:04 PM")
 			for _, avail := range driver.PunctualAvailabilities {
-				// Extract the day part of the punctual driver's date and compare.
-				availDate := time.Unix(avail.Date, 0)
-				if strings.ToLower(availDate.Format("Mon")) == dayOfWeek {
-					drivers = append(drivers, driver)
-					break
+				availyear, availmonth, availday := time.Unix(avail.Date, 0).Date()
+				if availyear == year && availmonth == month && availday == day {
+					startTime, err := time.Parse("3:04 PM", avail.StartTime)
+					if err != nil {
+						return nil, err
+					}
+
+					endTime, err := time.Parse("3:04 PM", avail.EndTime)
+					if err != nil {
+						return nil, err
+					}
+
+					// Convert DateHour_string to time.Time
+					dateHourTime, err := time.Parse("3:04 PM", dateHour_string)
+					if err != nil {
+						return nil, err
+					}
+					if dateHourTime.After(startTime) || dateHourTime.Equal(startTime) {
+						if dateHourTime.Before(endTime) || dateHourTime.Equal(endTime) {
+							drivers = append(drivers, driver)
+						}
+					}
+
 				}
+				// Check if the date and time match the punctual driver's availability.
+
 			}
 		} else if driver.AvailabilitiesType == internal.Regular {
 			if err := json.Unmarshal(availabilitiesJSON, &driver.RegularAvailabilities); err != nil {
 				return nil, err
 			}
-			// Convert the date to the day of the week and make it lowercase.
-			dayOfWeek := strings.ToLower(time.Unix(date, 0).UTC().Format("Mon"))
-			fmt.Println(dayOfWeek)
+
+			dayOfWeek := strings.ToLower(time.Unix(date, 0).Local().Format("Mon"))
+			dateHour := time.Unix(date, 0).UTC().Local()
+			dateHour_string := dateHour.Format("3:04 PM")
+
 			for _, avail := range driver.RegularAvailabilities {
-				fmt.Println(strings.ToLower(avail.DayOfWeek))
+
+				// Check if the day and time match the regular driver's availability.
 				if strings.ToLower(avail.DayOfWeek) == dayOfWeek {
-					drivers = append(drivers, driver)
-					break
+					startTime, err := time.Parse("3:04 PM", avail.StartTime)
+					if err != nil {
+						return nil, err
+					}
+
+					endTime, err := time.Parse("3:04 PM", avail.EndTime)
+					if err != nil {
+						return nil, err
+					}
+
+					// Convert DateHour_string to time.Time
+					dateHourTime, err := time.Parse("3:04 PM", dateHour_string)
+					if err != nil {
+						return nil, err
+					}
+
+					if dateHourTime.After(startTime) || dateHourTime.Equal(startTime) {
+						if dateHourTime.Before(endTime) || dateHourTime.Equal(endTime) {
+							drivers = append(drivers, driver)
+						}
+					}
 				}
 			}
 		}
--- a/storage/postgresql/schema.hcl
+++ b/storage/postgresql/schema.hcl
@@ -5,14 +5,6 @@ table "passengers" {
    null = false
    type = uuid
  }
-  column "passenger_departure_route" {
-    null = false
-    type = jsonb
-  }
-  column "passenger_destination_route" {
-    null = false
-    type = jsonb
-  }
  column "alias" {
    null = false
    type = varchar(15)
@@ -45,10 +37,6 @@ table "passengers" {
    null = true
    type = jsonb
  }
-  column "passenger_pickup_date" {
-    null = false
-    type = int
-  }
  primary_key {
    columns = [column.passenger_id]
  }
@@ -139,7 +127,27 @@ table "bookings" {
  }
  column "booking_status" {
    null = false
-    type = enum.booking_status
+    type = enum.bookingstatus
+  }
+  column "departure_address" {
+    null = false
+    type = jsonb
+  }
+  column "destination_address" {
+    null = false
+    type = jsonb
+  }
+  column "pickup_date" {
+    null = false
+    type = int
+  }
+  column "duration"{
+    null = false
+    type = int
+  }
+  column "distance"{
+    null = false
+    type = float
  }
  primary_key {
    columns = [column.booking_id]
@@ -153,8 +161,6 @@ table "bookings" {
    ref_columns = [table.passengers.column.passenger_id]
  }
 }
-
-
 enum "booking_status" {
  schema = schema.solidarity_service
  values = ["INITIATED", "WAITING_PASSENGER_CONFIRMATION", "WAITING_DRIVER_CONFIRMATION", "CONFIRMED", "CANCELLED", "COMPLETED_PENDING_VALIDATION", "VALIDATED"]