153 lines
3.9 KiB
Go
153 lines
3.9 KiB
Go
package storage
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
|
|
"git.coopgo.io/coopgo-platform/solidarity-transport/types"
|
|
"github.com/google/uuid"
|
|
"github.com/spf13/viper"
|
|
)
|
|
|
|
type MemoryStorage struct {
|
|
DriverRegularAvailabilities map[string]*types.DriverRegularAvailability
|
|
DriverJourneys map[string]*types.DriverJourney
|
|
Bookings map[string]*types.Booking
|
|
}
|
|
|
|
func NewMemoryStorage(cfg *viper.Viper) (MemoryStorage, error) {
|
|
return MemoryStorage{
|
|
DriverRegularAvailabilities: map[string]*types.DriverRegularAvailability{},
|
|
}, nil
|
|
}
|
|
|
|
func (s MemoryStorage) CreateDriverRegularAvailability(availability types.DriverRegularAvailability) error {
|
|
if availability.ID == "" {
|
|
availability.ID = uuid.NewString()
|
|
}
|
|
|
|
if s.DriverRegularAvailabilities[availability.ID] != nil {
|
|
return errors.New("availability already exists")
|
|
}
|
|
|
|
s.DriverRegularAvailabilities[availability.ID] = &availability
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s MemoryStorage) CreateDriverRegularAvailabilities(availabilities []*types.DriverRegularAvailability) error {
|
|
for _, availability := range availabilities {
|
|
if availability != nil {
|
|
if err := s.CreateDriverRegularAvailability(*availability); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s MemoryStorage) DeleteDriverRegularAvailability(driverid string, availabilityid string) error {
|
|
if s.DriverRegularAvailabilities[availabilityid] == nil {
|
|
return errors.New("availability doesn't exist")
|
|
}
|
|
if s.DriverRegularAvailabilities[availabilityid].DriverId != driverid {
|
|
return errors.New("unallowed to delete this availability : driver mismatch")
|
|
}
|
|
s.DriverRegularAvailabilities[availabilityid] = nil
|
|
return nil
|
|
}
|
|
|
|
func (s MemoryStorage) GetDriverRegularAvailability(driverid string, availabilityid string) (*types.DriverRegularAvailability, error) {
|
|
if s.DriverRegularAvailabilities[availabilityid] == nil {
|
|
return nil, errors.New("availability doesn't exist")
|
|
}
|
|
|
|
if s.DriverRegularAvailabilities[availabilityid].DriverId != driverid {
|
|
return nil, errors.New("unallowed to get this availability : driver mismatch")
|
|
}
|
|
|
|
return s.DriverRegularAvailabilities[availabilityid], nil
|
|
}
|
|
|
|
func (s MemoryStorage) GetDriverRegularAvailabilities(driverid string) ([]*types.DriverRegularAvailability, error) {
|
|
result := []*types.DriverRegularAvailability{}
|
|
|
|
for _, a := range s.DriverRegularAvailabilities {
|
|
if a.DriverId == driverid {
|
|
result = append(result, a)
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (s MemoryStorage) GetRegularAvailabilities(day int, timeInDay string) ([]*types.DriverRegularAvailability, error) {
|
|
results := []*types.DriverRegularAvailability{}
|
|
|
|
for _, a := range s.DriverRegularAvailabilities {
|
|
if a.Day == day && strings.Compare(a.StartTime, timeInDay) <= 0 && strings.Compare(a.EndTime, timeInDay) >= 0 {
|
|
results = append(results, a)
|
|
}
|
|
}
|
|
return results, nil
|
|
}
|
|
|
|
func (s MemoryStorage) PushDriverJourneys(driverjourneys []*types.DriverJourney) error {
|
|
for _, j := range driverjourneys {
|
|
s.DriverJourneys[j.Id] = j
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s MemoryStorage) GetDriverJourney(id string) (res *types.DriverJourney, err error) {
|
|
res = s.DriverJourneys[id]
|
|
|
|
if res == nil {
|
|
err = errors.New("not found")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s MemoryStorage) CreateBooking(booking types.Booking) error {
|
|
if booking.Id == "" {
|
|
booking.Id = uuid.NewString()
|
|
}
|
|
|
|
if s.Bookings[booking.Id] != nil {
|
|
return errors.New("booking already exists")
|
|
}
|
|
|
|
s.Bookings[booking.Id] = &booking
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s MemoryStorage) GetAllBookings() ([]*types.Booking, error) {
|
|
res := []*types.Booking{}
|
|
|
|
for _, b := range s.Bookings {
|
|
res = append(res, b)
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func (s MemoryStorage) GetBooking(id string) (res *types.Booking, err error) {
|
|
res = s.Bookings[id]
|
|
|
|
if res == nil {
|
|
err = errors.New("not found")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s MemoryStorage) UpdateBookingStatus(bookingid string, newStatus string) error {
|
|
b := s.Bookings[bookingid]
|
|
|
|
if b == nil {
|
|
return errors.New("booking doesn't exist")
|
|
}
|
|
|
|
b.Status = newStatus
|
|
|
|
return nil
|
|
}
|