Changes between Version 1 and Version 2 of AdvancedApplicationDevelopment

Timestamp:

05/28/26 05:25:31 (13 days ago)

Author:

181201

Comment:

--

AdvancedApplicationDevelopment

@@ -22 +22 @@
 
 === Registering a new user ===
+
 {{{
 #!java
     @Transactional
     public User registerUser(String username, String password, String firstName, String lastName, String email, String role) {
+        logger.info("Attempting to register new user '{}' with role '{}'", username, role);
+
+        // 1. Ensure username is unique
         if (userRepository.findByUsername(username).isPresent()) {
+            logger.error("VALIDATION FAILED: Username '{}' is already taken", username);
             throw new IllegalArgumentException("Username already exists!");
         }
 
+        // 2. Validate Role Assignment
         User newUser;
         if ("OWNER".equalsIgnoreCase(role)) {
@@ -36 +42 @@
             newUser = new PetSitter();
         } else {
+            logger.error("VALIDATION FAILED: Invalid role '{}' provided", role);
             throw new IllegalArgumentException("Invalid role selected!");
         }
@@ -45 +52 @@
         newUser.setEmail(email);
 
-        // Saving a PetOwner or PetSitter automatically saves to the parent 'users' table with InhertianceType.JOINED
+        // 3. Saving a PetOwner or PetSitter automatically cascades to the parent 'users' table with InheritanceType.JOINED
+        User savedUser;
         if (newUser instanceof PetOwner) {
-            return petOwnerRepository.save((PetOwner) newUser);
+            savedUser = petOwnerRepository.save((PetOwner) newUser);
         } else {
-            return petSitterRepository.save((PetSitter) newUser);
-        }
+            savedUser = petSitterRepository.save((PetSitter) newUser);
+        }
+        
+        logger.info("Successfully registered user '{}' with ID {}", savedUser.getUsername(), savedUser.getUserId());
+        return savedUser;
     }
 }}}
 
 === Creating a new booking ===
+
 {{{
 #!java
     @Transactional
     public Booking createBooking(String ownerId, String sitterId, LocalDate dateFrom, LocalDate dateTo, String address, List<String> petIds, String serviceType) {
-        PetOwner owner = petOwnerRepository.findById(ownerId).orElseThrow(() -> new IllegalArgumentException("Invalid owner"));
-        PetSitter sitter = petSitterRepository.findById(sitterId).orElseThrow(() -> new IllegalArgumentException("Invalid sitter"));
+        logger.info("Attempting to create booking. Owner: {}, Sitter: {}", ownerId, sitterId);
+
+        // 1. Initial Validation
+        if (dateFrom == null || dateTo == null || dateFrom.isAfter(dateTo)) {
+            logger.error("VALIDATION FAILED: Invalid date range provided");
+            throw new IllegalArgumentException("Booking dates are invalid");
+        }
+        if (petIds == null || petIds.isEmpty()) {
+            logger.error("VALIDATION FAILED: No pets selected for booking");
+            throw new IllegalArgumentException("At least one pet must be selected");
+        }
+
+        // 2.Fetch Entities
+        PetOwner owner = petOwnerRepository.findById(ownerId).orElseThrow(() -> {
+            logger.error("VALIDATION FAILED: Owner not found with ID: {}", ownerId);
+            return new IllegalArgumentException("Invalid owner");
+        });
+        
+        PetSitter sitter = petSitterRepository.findById(sitterId).orElseThrow(() -> {
+            logger.error("VALIDATION FAILED: Sitter not found with ID: {}", sitterId);
+            return new IllegalArgumentException("Invalid sitter");
+        });
+        
         List<Pet> pets = petRepository.findAllById(petIds);
-
+        if (pets.size() != petIds.size()) {
+            logger.error("VALIDATION FAILED: One or more pet IDs do not exist in the database");
+            throw new IllegalArgumentException("Invalid pets selected");
+        }
+
+        // 3. Entity Construction
         Booking booking = new Booking();
         booking.setOwner(owner);
@@ -78 +116 @@
         }
         
-        return bookingRepository.save(booking);
+        // 4. Write Operation
+        Booking savedBooking = bookingRepository.save(booking);
+        logger.info("Successfully created booking {} for owner {}", savedBooking.getBookingId(), owner.getUsername());
+        return savedBooking;
     }
 }}}
@@ -97 +138 @@
 
 === Adding a new pet ===
+
 {{{
 #!java
     @Transactional
     public Pet addPet(String name, Integer age, String specialNeeds, String description, String photoUrl, String ownerId, String petTypeId) {
-        PetOwner owner = petOwnerRepository.findById(ownerId).orElseThrow(() -> new IllegalArgumentException("Invalid owner ID"));
-        PetType petType = petTypeRepository.findById(petTypeId).orElseThrow(() -> new IllegalArgumentException("Invalid pet type ID"));
+        logger.info("Attempting to add pet '{}' for owner ID: {}", name, ownerId);
+
+        if (name == null || name.isBlank()) {
+            logger.error("VALIDATION FAILED: Pet name is null or empty");
+            throw new IllegalArgumentException("Pet name is strictly required");
+        }
+
+        // 1. Read/Verify Owner exists
+        PetOwner owner = petOwnerRepository.findById(ownerId).orElseThrow(() -> {
+            logger.error("VALIDATION FAILED: Owner not found with ID: {}", ownerId);
+            return new IllegalArgumentException("Invalid owner ID");
+        });
+        
+        // 2. Read/Verify PetType exists
+        PetType petType = petTypeRepository.findById(petTypeId).orElseThrow(() -> {
+            logger.error("VALIDATION FAILED: Pet type not found with ID: {}", petTypeId);
+            return new IllegalArgumentException("Invalid pet type ID");
+        });
         
         Pet pet = new Pet();
@@ -113 +171 @@
         pet.setPetType(petType);
         
-        return petRepository.save(pet);
+        // 3. Insert the new Pet
+        Pet savedPet = petRepository.save(pet);
+        logger.info("Successfully added pet '{}' under owner '{}'", savedPet.getName(), owner.getUsername());
+        
+        return savedPet;
     }
 }}}
 
 === Managing Reviews ===
+
 {{{
 #!java
     @Transactional
     public Review addReview(String bookingId, Integer rating, String comment) {
-        Booking booking = bookingRepository.findById(bookingId).orElseThrow(() -> new IllegalArgumentException("Invalid booking"));
+        logger.info("Attempting to add review for booking ID: {}", bookingId);
+
+        if (rating == null || rating < 1 || rating > 5) {
+            logger.error("VALIDATION FAILED: Invalid rating: {}", rating);
+            throw new IllegalArgumentException("Rating must be between 1 and 5");
+        }
+
+        Booking booking = bookingRepository.findById(bookingId).orElseThrow(() -> {
+            logger.error("VALIDATION FAILED: Booking not found with ID: {}", bookingId);
+            return new IllegalArgumentException("Invalid booking");
+        });
+
+        // 1. Validate Business Logic
+        if (!"Completed".equalsIgnoreCase(booking.getStatus())) {
+            logger.error("VALIDATION FAILED: Cannot review booking in status: {}", booking.getStatus());
+            throw new IllegalStateException("Only completed bookings can be reviewed");
+        }
+
+        // 2. Create and save the review
         Review review = new Review();
         review.setBooking(booking);
         review.setRating(rating);
         review.setComment(comment);
-        return reviewRepository.save(review);
-    }
-
+        
+        Review savedReview = reviewRepository.save(review);
+        logger.info("Successfully inserted review for booking: {}", bookingId);
+        
+        // 3. Update the booking status
+        booking.setStatus("Reviewed");
+        bookingRepository.save(booking);
+        logger.info("Booking {} status successfully updated to Reviewed", bookingId);
+        
+        return savedReview;
+    }
+}}}
+
+{{{
+#!java
     @Transactional(readOnly = true)
     public Double getAverageRating(String sitterId) {
         return reviewRepository.getAverageRatingForSitter(sitterId);
+    }
+}}}
+
+=== Cascading Deletes & Rollback Demonstration ===
+This method deletes a user and all of their related data. If the application crashes before the final step, all previous deletions in the transaction are automatically rolled back, preventing orphaned data.
+{{{
+#!java
+    @Transactional
+    public void deleteUserAccount(String userId) {
+        logger.info("Attempting to securely delete user account with ID: {}", userId);
+        
+        // 1. Fetch and delete all bookings associated with the user
+        List<Booking> ownerBookings = bookingService.getBookingsForOwner(userId);
+        ownerBookings.forEach(b -> bookingService.deleteBooking(b.getBookingId()));
+        
+        List<Booking> sitterBookings = bookingService.getBookingsForSitter(userId);
+        sitterBookings.forEach(b -> bookingService.deleteBooking(b.getBookingId()));
+        
+        // 2. Delete all pets owned by this user
+        List<Pet> pets = petService.getPetsByOwner(userId);
+        pets.forEach(p -> petService.deletePetAdmin(p.getPetId()));
+        
+        // Uncomment this temporarily for testing, validation for deletion
+        // if (true) {
+        //     throw new RuntimeException("Simulated Server Crash!");
+        // }
+        
+        // 3. Delete the user finally
+        userRepository.deleteById(userId);
+        logger.info("Successfully deleted user account and all related data for ID: {}", userId);
     }
 }}}