Fix/external service call

README.md

@@ -117,7 +117,7 @@ Create hotel-user , hotel-admin (password: test)
 ```
 
 
-docker build -t devopszms2024/zms-devops-booking-service:3.20.5 .
-docker push devopszms2024/zms-devops-booking-service:3.20.5
+docker build -t devopszms2024/zms-devops-booking-service:latest .
+docker push devopszms2024/zms-devops-booking-service:latest
 kubectl replace --force -f k8s/
 kubectl replace --force -f istio/

application/merge_overlapping_periods.go

@@ -51,14 +51,14 @@ func insertPeriod(newPeriod *domain.UnavailabilityPeriod, periods []domain.Unava
 	return mergeOverlappingPeriods(periods)
 }
 
-func removePeriod(toRemove domain.UnavailabilityPeriod, periods []domain.UnavailabilityPeriod) []domain.UnavailabilityPeriod {
+func removePeriod(toRemove domain.UnavailabilityPeriod, periods []domain.UnavailabilityPeriod, shouldRemainReserved bool) []domain.UnavailabilityPeriod {
 	var result []domain.UnavailabilityPeriod
 
 	for _, period := range periods {
 		if toRemove.Start.After(period.End) || toRemove.End.Before(period.Start) {
 			result = append(result, period)
 		} else {
-			if period.Reason == domain.Reserved {
+			if period.Reason == domain.Reserved && shouldRemainReserved {
 				result = append(result, period)
 			} else {
 				if toRemove.Start.After(period.Start) && toRemove.End.Before(period.End) {

application/reservation_request_service.go

@@ -42,6 +42,7 @@ func (service *ReservationRequestService) AddReservationRequest(reservationReque
 
 	if isAutomatic {
 		err = service.ApproveRequest(*requestId)
+		log.Printf("prosao2")
 		service.produceNotification("reservation-request.created", reservationRequest.HostId, reservationRequest.Id.Hex(), "automatic")
 	} else {
 		service.produceNotification("reservation-request.created", reservationRequest.HostId, reservationRequest.Id.Hex(), "")
@@ -80,7 +81,9 @@ func (service *ReservationRequestService) ApproveRequest(id primitive.ObjectID)
 	if err != nil {
 		return err
 	}
+	log.Printf("stigao ovde")
 	service.produceNotification("host-reviewed-reservation-request", reservationRequest.UserId, reservationRequest.Id.Hex(), "accept-request")
+	log.Printf("prosao")
 	return nil
 }
 
@@ -103,11 +106,7 @@ func (service *ReservationRequestService) DeclineRequest(id primitive.ObjectID)
 }
 
 func (service *ReservationRequestService) DeleteRequest(id primitive.ObjectID) error {
-	_, err := service.store.Get(id)
-	if err != nil {
-		return err
-	}
-	err = service.store.Delete(id)
+	err := service.store.Delete(id)
 	if err != nil {
 		return err
 	}
@@ -148,13 +147,18 @@ func (service *ReservationRequestService) DeclineReservation(id primitive.Object
 		End:   reservationRequest.End,
 	}
 
-	err = service.unavailabilityService.RemoveUnavailabilityPeriod(reservationRequest.AccommodationId, &unavailabilityPeriod) // todom
+	log.Printf("stigao DeclineReservation")
+	log.Printf("unavailabilityPeriod start %s", unavailabilityPeriod.Start)
+	log.Printf("unavailabilityPeriod end %s", unavailabilityPeriod.End)
+	err = service.unavailabilityService.RemoveUnavailabilityPeriod(reservationRequest.AccommodationId, &unavailabilityPeriod, false)
 	if err != nil {
 		return err
 	}
 
+	log.Printf("stigao do produce")
 	service.produceNotification("reservation.canceled", reservationRequest.HostId, reservationRequest.Id.Hex(), "canceled")
 
+	log.Printf("prosao DeclineReservation")
 	return nil
 }
 
@@ -239,7 +243,7 @@ func (service *ReservationRequestService) produceNotification(topic string, rece
 }
 
 func (service *ReservationRequestService) CheckGuestHasReservationForHost(reviewerId string, hostId string) bool {
-	requests, err := service.store.GetByClientIdAndHostId(reviewerId, hostId)
+	requests, err := service.store.GetPastAcceptedReservationRequestByClientIdAndHostId(reviewerId, hostId)
 	if err != nil {
 		return false
 	}
@@ -253,3 +257,28 @@ func (service *ReservationRequestService) CheckGuestHasReservationForAccommodati
 	}
 	return requests != nil && len(requests) > 0
 }
+
+func (service *ReservationRequestService) CheckAccommodationHasReservation(accommodationId primitive.ObjectID) bool {
+	status := domain.Approved
+	reservationRequests, err := service.GetByAccommodationId(accommodationId, &status)
+	if err != nil {
+		return false
+	}
+	for _, reservationRequest := range reservationRequests {
+		if isReservationInFuture(reservationRequest) {
+			return false
+		}
+	}
+
+	for _, reservationRequest := range reservationRequests {
+		if err := service.DeleteRequest(reservationRequest.Id); err != nil {
+			return false
+		}
+	}
+
+	if err := service.unavailabilityService.DeleteByAccommodationId(accommodationId); err != nil {
+		return false
+	}
+
+	return true
+}

application/unavailability_service.go

@@ -2,6 +2,7 @@ package application
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"github.com/ZMS-DevOps/booking-service/domain"
 	"github.com/ZMS-DevOps/booking-service/infrastructure/dto"
@@ -74,24 +75,47 @@ func (service *UnavailabilityService) AddUnavailabilityPeriod(accommodationId pr
 		return err
 	}
 	period.Id = primitive.NewObjectID()
+
+	if !(service.checkIfCouldAddUnavailability(unavailability, period)) {
+		return errors.New("could not add unavailability period")
+	}
+
 	if err := service.store.UpdateUnavailabilityPeriods(unavailability.Id, insertPeriod(period, unavailability.UnavailabilityPeriods)); err != nil {
 		return err
 	}
 
+	if err := service.reservationRequestStore.DeleteByAccommodation(accommodationId); err != nil {
+		return err
+	}
+
 	return nil
 }
 
-func (service *UnavailabilityService) RemoveUnavailabilityPeriod(accommodationId primitive.ObjectID, period *domain.UnavailabilityPeriod) error {
+func (service *UnavailabilityService) checkIfCouldAddUnavailability(unavailability *domain.Unavailability, period *domain.UnavailabilityPeriod) bool {
+	for _, unavailabilityPeriod := range unavailability.UnavailabilityPeriods {
+		if periodsOverlap(unavailabilityPeriod.Start, unavailabilityPeriod.End, period.Start, period.End) {
+			if unavailabilityPeriod.Reason == domain.Reserved {
+				return false
+			}
+
+		}
+	}
+	return true
+}
+
+func (service *UnavailabilityService) RemoveUnavailabilityPeriod(accommodationId primitive.ObjectID, period *domain.UnavailabilityPeriod, shouldRemainReserved bool) error {
 	unavailability, err := service.store.GetByAccommodationId(accommodationId)
+	log.Printf("unavailability %v removed from unavailability period %v\n", unavailability, period)
 	if err != nil {
 		return err
 	}
-	period.Id = primitive.NewObjectID()
 
-	updatedPeriods := removePeriod(*period, unavailability.UnavailabilityPeriods)
+	updatedPeriods := removePeriod(*period, unavailability.UnavailabilityPeriods, shouldRemainReserved)
+	log.Printf("unavailability period %v removed from unavailability periods %v\n", updatedPeriods, period)
 	if err := service.store.UpdateUnavailabilityPeriods(unavailability.Id, updatedPeriods); err != nil {
 		return err
 	}
+	log.Printf("vrating period removed from unavailability periods %v\n", updatedPeriods)
 
 	return nil
 }
@@ -108,6 +132,10 @@ func (service *UnavailabilityService) GetByAccommodationId(id primitive.ObjectID
 	return service.store.GetByAccommodationId(id)
 }
 
+func (service *UnavailabilityService) DeleteByAccommodationId(id primitive.ObjectID) error {
+	return service.store.DeleteByAccommodationId(id)
+}
+
 func (service *UnavailabilityService) GetByHostId(id string) ([]*domain.Unavailability, error) {
 	return service.store.GetByHostId(id)
 }
@@ -145,26 +173,32 @@ func (service *UnavailabilityService) DeleteHost(hostId string) (bool, error) {
 	}
 	for _, unavailability := range unavailabilityList {
 		for _, period := range unavailability.UnavailabilityPeriods {
+			log.Printf("start period %s\n", period.Start)
+			log.Printf("reason %d\n", period.Reason)
 			if isFuturePeriod(period) && period.Reason == domain.Reserved {
 				return false, nil
 			}
 		}
 	}
+	log.Printf("dosao 1 deleteHost")
 
 	service.produceDeleteAccommodationNotification(hostId)
+	log.Printf("dosao 2 deleteHost")
 	err = service.reservationRequestStore.DeleteByHost(hostId)
+	log.Printf("dosao 3 deleteHost")
 	if err != nil {
 		return false, err
 	}
 	return true, nil
 }
 
 func (service *UnavailabilityService) IsAutomatic(accommodationId primitive.ObjectID) (bool, error) {
-	var unavailability, err = service.store.GetByAccommodationId(accommodationId)
+	var accommodation, err = service.store.GetByAccommodationId(accommodationId)
+	log.Printf("accommodation: %v", accommodation)
 	if err != nil {
 		return false, err
 	}
-	return unavailability.ReviewReservationRequestAutomatically, nil
+	return accommodation.ReviewReservationRequestAutomatically, nil
 }
 
 func isFuturePeriod(period domain.UnavailabilityPeriod) bool {
@@ -173,8 +207,7 @@ func isFuturePeriod(period domain.UnavailabilityPeriod) bool {
 }
 
 func periodsOverlap(start1, end1, start2, end2 time.Time) bool {
-	return start1.After(start2) && start1.Before(end2) ||
-		start1.Before(start2) && end1.After(start2)
+	return start1.Before(end2) && end1.After(start2)
 }
 
 func (service *UnavailabilityService) produceDeleteAccommodationNotification(hostId string) {

domain/reservation_request_store.go

@@ -18,5 +18,7 @@ type ReservationRequestStore interface {
 	GetByClientIdAndTimeAndSearch(guestId string, past bool, search string) ([]*ReservationRequest, error)
 	DeleteByHost(hostId string) error
 	GetByClientIdAndHostId(reviewerId string, hostId string) ([]*ReservationRequest, error)
+	GetPastAcceptedReservationRequestByClientIdAndHostId(reviewerId string, hostId string) ([]*ReservationRequest, error)
 	GetByClientIdAndAccommodationId(reviewerId string, accommodationId primitive.ObjectID) ([]*ReservationRequest, error)
+	DeleteByAccommodation(accommodationId primitive.ObjectID) error
 }

domain/unavailability_store.go

@@ -6,6 +6,7 @@ type UnavailabilityStore interface {
 	Get(id primitive.ObjectID) (*Unavailability, error)
 	Insert(unavailability *Unavailability) error
 	DeleteAll()
+	DeleteByAccommodationId(accommodationId primitive.ObjectID) error
 	GetAll() ([]*Unavailability, error)
 	GetPeriod(id primitive.ObjectID) (UnavailabilityPeriod, error)
 	Update(id primitive.ObjectID, unavailability *Unavailability) error

infrastructure/api/booking_grpc_api.go

@@ -103,6 +103,15 @@ func (handler *BookingHandler) CheckGuestHasReservationForAccommodation(ctx cont
 	return &pb.CheckGuestHasReservationForAccommodationResponse{HasReservation: hasReservation}, nil
 }
 
+func (handler *BookingHandler) CheckAccommodationHasReservation(ctx context.Context, request *pb.CheckAccommodationHasReservationRequest) (*pb.CheckAccommodationHasReservationResponse, error) {
+	accommodationId, err := primitive.ObjectIDFromHex(request.AccommodationId)
+	if err != nil {
+		return nil, err
+	}
+	canDelete := handler.reservationRequestService.CheckAccommodationHasReservation(accommodationId)
+	return &pb.CheckAccommodationHasReservationResponse{Success: canDelete}, nil
+}
+
 func convertHexToObjectIDs(hexIDs []string) ([]primitive.ObjectID, error) {
 	var objectIDs []primitive.ObjectID
 

infrastructure/api/reservation_request_handler.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ZMS-DevOps/booking-service/infrastructure/dto"
 	"github.com/gorilla/mux"
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"log"
 	"net/http"
 )
 
@@ -23,13 +24,11 @@ func NewReservationRequestHandler(service *application.ReservationRequestService
 
 func (handler *ReservationRequestHandler) Init(router *mux.Router) {
 	router.HandleFunc("/booking/request", handler.AddRequest).Methods("POST")
-	router.HandleFunc("/booking/request/user/{id}", handler.GetByClient).Methods("GET")
-	router.HandleFunc("/booking/request/{id}", handler.GetAll).Methods("GET")
-	router.HandleFunc("/booking/request/{id}/approve", handler.Approve).Methods("PUT")
-	router.HandleFunc("/booking/request/{id}/decline", handler.Decline).Methods("PUT")
-	router.HandleFunc("/booking/request/{id}", handler.Delete).Methods("DELETE")
-	router.HandleFunc("/booking/reservation/{id}/decline", handler.DeclineReservation).Methods("PUT")
+	router.HandleFunc("/booking/reservation/decline/{id}", handler.DeclineReservation).Methods("PUT")
 	router.HandleFunc("/booking/request/user/{id}", handler.GetFilteredRequests).Methods("GET")
+	router.HandleFunc("/booking/request/all/{id}", handler.GetAll).Methods("GET")
+	router.HandleFunc("/booking/request/approve/{id}", handler.Approve).Methods("PUT")
+	router.HandleFunc("/booking/request/decline/{id}", handler.Decline).Methods("PUT")
 }
 
 func (handler *ReservationRequestHandler) AddRequest(w http.ResponseWriter, r *http.Request) {
@@ -38,13 +37,17 @@ func (handler *ReservationRequestHandler) AddRequest(w http.ResponseWriter, r *h
 		handleError(w, http.StatusBadRequest, "Invalid request payload")
 		return
 	}
+	log.Printf("prvi print")
+	log.Printf("adddto print %v", addReservationRequestDto.AccommodationId)
 
 	if err := dto.ValidateAddRegistrationRequestDto(addReservationRequestDto); err != nil {
 		handleError(w, http.StatusBadRequest, err.Error())
 		return
 	}
+	log.Printf("drugi print")
 
 	newReservationRequest := dto.MapRegistrationRequest(addReservationRequestDto)
+	log.Printf("newReservationRequest print %v", newReservationRequest)
 
 	if err := handler.service.AddReservationRequest(newReservationRequest); err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
@@ -134,22 +137,6 @@ func (handler *ReservationRequestHandler) Decline(w http.ResponseWriter, r *http
 	w.WriteHeader(http.StatusOK)
 }
 
-func (handler *ReservationRequestHandler) Delete(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	accommodationId, err := primitive.ObjectIDFromHex(vars["id"])
-	if err != nil {
-		handleError(w, http.StatusBadRequest, err.Error())
-		return
-	}
-
-	if err := handler.service.DeleteRequest(accommodationId); err != nil {
-		w.WriteHeader(http.StatusNotFound)
-		return
-	}
-
-	w.WriteHeader(http.StatusOK)
-}
-
 func (handler *ReservationRequestHandler) DeclineReservation(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
 	accommodationId, err := primitive.ObjectIDFromHex(vars["id"])

infrastructure/api/unavailability_handler.go

@@ -27,9 +27,8 @@ func NewUnavailabilityHandler(service *application.UnavailabilityService) *Unava
 }
 
 func (handler *UnavailabilityHandler) Init(router *mux.Router) {
-	router.HandleFunc("/booking/health", handler.GetHealthCheck).Methods("GET")
 	router.HandleFunc("/booking/unavailability", handler.GetAll).Methods("GET")
-	router.HandleFunc("/booking/unavailability/{id}", handler.GetByAccommodationId).Methods("GET")
+	router.HandleFunc("/booking/unavailability/accommodation/{id}", handler.GetByAccommodationId).Methods("GET")
 	router.HandleFunc("/booking/unavailability/host/{id}", handler.GetByHostId).Methods("GET")
 	router.HandleFunc("/booking/unavailability/remove", handler.DeletePeriod).Methods("PUT")
 	router.HandleFunc("/booking/unavailability/add", handler.AddPeriod).Methods("PUT")
@@ -70,7 +69,7 @@ func (handler *UnavailabilityHandler) DeletePeriod(w http.ResponseWriter, r *htt
 	}
 
 	removedUnavailabilityPeriod := dto.MapUnavailabilityPeriod(&manageUnavailabilityPeriodDto)
-	if err := handler.service.RemoveUnavailabilityPeriod(manageUnavailabilityPeriodDto.AccommodationId, removedUnavailabilityPeriod); err != nil {
+	if err := handler.service.RemoveUnavailabilityPeriod(manageUnavailabilityPeriodDto.AccommodationId, removedUnavailabilityPeriod, true); err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

infrastructure/dto/add_registration_request.go

@@ -8,14 +8,14 @@ import (
 )
 
 type AddReservationRequestDto struct {
-	AccommodationId   primitive.ObjectID `bson:"accommodation_id"`
-	AccommodationName string             `bson:"accommodation_name"`
-	HostId            string             `bson:"host_id"`
-	UserId            string             `bson:"user_id"`
-	Start             time.Time          `bson:"start"`
-	End               time.Time          `bson:"end"`
-	NumberOfGuests    int                `bson:"number_of_guests"`
-	PriceTotal        float32            `bson:"price_total"`
+	AccommodationId   primitive.ObjectID `json:"accommodation_id"`
+	AccommodationName string             `json:"accommodation_name"`
+	HostId            string             `json:"host_id"`
+	UserId            string             `json:"user_id"`
+	Start             time.Time          `json:"start"`
+	End               time.Time          `json:"end"`
+	NumberOfGuests    int                `json:"number_of_guests"`
+	PriceTotal        float32            `json:"price_total"`
 }
 
 func ValidateAddRegistrationRequestDto(dto AddReservationRequestDto) error {