Pipes - Nkiru - Hotel

.gitignore

@@ -34,6 +34,7 @@ build-iPhoneSimulator/
 /_yardoc/
 /doc/
 /rdoc/
+.DS_Store
 
 ## Environment normalization:
 /.bundle/

Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib"]
+  t.warning = true
+  t.test_files = FileList['specs/*_spec.rb']
+end
+
+task default: :test

design-activity.md

@@ -0,0 +1,108 @@
+What classes does each implementation include? Are the lists the same?
+
+Implementation A & B includes the following classes:
+  CartEntry
+  ShoppingCart
+  Order
+
+Write down a sentence to describe each class.
+implementation A:
+  Class CartEntry stores the unit price and quantity of an item
+
+  ShoppingCart stores the collection of all the items
+
+  Order creates a new ShoppingCart and calculates the subtotal and total price for the items.
+
+  Implementation B:
+  CartEntry stores the unit price and quantity of an item and calculates the price for each item.
+
+  ShoppingCart stores the collection of all the items and calculates the subtotal of all the items.
+
+  Order creates a new ShoppingCart and calculates the total price of all the items by taking the subtotal from the ShoppingCart class and adding a sales tax.
+
+
+How do the classes relate to each other? It might be helpful to draw a diagram on a whiteboard or piece of paper.
+
+What data does each class store? How (if at all) does this differ between the two implementations?
+Implementation A
+  CartEntry class stores unit price and quantity
+
+  ShoppingCart class stores an array of all the cart entry items
+
+  Order class stores the sales tax (constant) and shopping cart object.
+
+  Implementation B
+  CartEntry stores the unit price and quantity
+
+  ShoppingCart stores an array of the cart entry items
+
+  Order stores sales tax (constant) and shopping cart object.
+
+  Both implementations are the same with regards to what is stored in each class.
+
+
+What methods does each class have? How (if at all) does this differ between the two implementations?
+  Implementation A
+  CartEntry - initialize method
+  ShoppingCart - initialize method
+  Order - Initialize method and total price method
+
+  Implementation B
+  CartEntry - Initialize method and price method
+  ShoppingCart - Initialize method and price method
+  Order - Initialize and total price method
+
+  In Implementation B, CartEntry and ShoppingCart each has an additional method that calculates price.
+
+
+Consider the Order#total_price method. In each implementation:
+Is logic to compute the price delegated to "lower level" classes like ShoppingCart and CartEntry, or is it retained in Order?
+  Implementation A
+  Logic to compute price is retained in Order.  
+
+  Implementation B
+  Logic to compute price is delegated to the CartEntry and ShoppingCart classes.  Order only requires the subtotal when a ShoppingCart object is created to calculate the total price with tax.
+
+Does total_price directly manipulate the instance variables of other classes?
+  No, it doesn't but in Implementation A, the Order class has access to the instances variables in the CartEntry and ShoppingCart classes.
+
+If we decide items are cheaper if bought in bulk, how would this change the code? Which implementation is easier to modify?
+  Implementation B
+    BULK_QUANTITY = 100
+    DISCOUNT = 0.1
+
+    def price
+      if @quantity >= BULK_QUANTITY
+        return @unit_price * @quantity * (1.0 - DISCOUNT)
+      else
+        return @unit_price * @quantity
+      end
+    end
+
+  Implementation B is a better option because only CartEntry will need to be modified without causing major changes downstream.
+
+  In Implementation A, the discount price and bulk quantity will need to added to the Order class.
+
+Which implementation better adheres to the single responsibility principle?
+  Implementation B, each class is responsible for it's own behavior and state.
+
+Bonus question once you've read Metz ch. 3: Which implementation is more loosely coupled?
+  Implementation B.  According to Sandi Metz, the more one class knows about another, the more tightly it is coupled (as seen in Implementation A).
+
+  In Implementation A, Order class knows the order of CartEntry's arguments (i.e unit price & quantity)
+  Order class has access to CartEntry's unit price & quantity due to the attr_reader.  Order class knows the name of another class i.e cart = ShoppingCart.new as well as CartEntry (I made the assumption that entry is an instance of CartEntry)
+
+  In Implementation B, there is no attr_reader and each class has its own specific responsibility.
+
+Once you've responded to the prompts, git add design-activity.md and git commit!
+
+
+HOTEL ACTIVITY
+
+It seems that most of my classes are loosely coupled but there is opportunity to refactor the booking system.
+
+In the BookingSystem class, (lines 41 and 54), it will be better to create a new method for reservation date range in reservation class and call it in print reservation and room available methods.
+
+Check the date_range in the reservation class instead of calling the method directly in the booking system class.  Furthermore, I can remove date_range from the attribute reader in the reservation class (I tried this and it is not true!).
+
+After transferring the responsibility of checking if a reservation date overlaps to the reservation class, I am not so sure it was necessary.  It seems to make more sense to me initially the way it was designed.  That is, check if a reservation check is available then book.  Thoughts please.  

lib/booking_system.rb

@@ -0,0 +1,166 @@
+require_relative 'room'
+require_relative 'reservation'
+require_relative 'date_range'
+require 'date'
+
+
+module Hotel
+  class BookingSystem
+    attr_reader :collection_of_rooms, :collection_of_reservations, :block_rooms
+
+    #Access list of all rooms in the hotel.
+    def initialize
+      @collection_of_reservations = []
+      @collection_of_rooms = []
+      @block_rooms = []
+      build_rooms
+      # is it better to create a separate method and call in initialize?
+      # 20.times do |i|
+      #   room = Hotel::Room.new(i + 1, 200)
+      #   @collection_of_rooms << room
+      # end
+    end
+
+    def build_rooms
+      20.times do |i|
+        room = Hotel::Room.new(i + 1, 200)
+        @collection_of_rooms << room
+      end
+    end
+    #
+    # def make_block_rooms(date_range, num_rooms)
+    #
+    #     end
+    #   end
+    #   # take in the num_rooms to determine # iteration
+    #   # loop through the collection_of_rooms to find the first available rooms that match criteria
+    #   # if you find the num_rooms before looping through entire array, break; if not continue
+    # end
+
+
+    def print_reservations(date_range)
+      reservation_list = []
+      @collection_of_reservations.each do |reservation|
+        if reservation.date_range.date_include?(date_range)
+          # refactor: create new method for reservation date range in reservation class and call it in print reservation.
+          reservation_list << reservation
+        end
+      end
+      return reservation_list
+    end
+
+    def room_available(room_number, res_date)
+      room_is_available = true
+
+      @collection_of_reservations.each do |reservation|
+        reserved_rooms = reservation.reserved_rooms
+        # overlap = reservation.date_range.date_overlap?(date_range) #initial design
+        if !reservation.overlap(res_date) # new design
+          # # refactor
+          # puts reserved_rooms.class
+          reserved_rooms.each do |room|
+            puts room.room_num
+            if room.room_num == room_number && overlap == true
+              room_is_available = false
+            end
+          end
+        else
+          return false
+        end
+      end
+
+      # if room_is_available
+      #   @block_rooms.each do |block|
+      #     block.include room.room_num
+      #     room_is_available = false
+        # if the room is in a block for that date range, room_is_available = false
+      # end
+
+      return room_is_available
+    end
+
+    def make_reservation(name,room_num,date_range)
+      reserved_rooms = []
+
+      if room_available(room_num,date_range) == true
+
+        reserved_rooms << @collection_of_rooms[room_num - 1]
+        reservation = Hotel::Reservation.new(name,reserved_rooms,date_range)
+        @collection_of_reservations << reservation
+      else
+        raise ArgumentError.new("Room unavailable")
+      end
+      return reservation
+    end
+
+  end #end of class
+end # end of module
+
+<<<<<<< HEAD
+#TESTING#####
+# new_reservation = Hotel::BookingSystem.new
+# # puts new_reservation.collection_of_rooms
+# checkin_date = Date.new(2001,01,01)
+# checkout_date = Date.new(2001,01,31)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+# puts new_reservation.make_reservation("bob", 1, dates)
+# puts
+# puts new_reservation.collection_of_reservations
+# #
+# trey = new_reservation.make_reservation("trey", 2, dates)
+# puts trey.total_cost
+# puts "this is the total cost"
+# new_reservation.collection_of_reservations
+
+
+#TESTING FOR AVAILABILITY
+# puts new_reservation.room_available(1)
+# puts new_reservation.room_available(9)
+# checkin_date = Date.new(2001,01,05)
+# checkout_date = Date.new(2001,01,14)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+# new_reservation.make_reservation("trey", 2, dates)
+# puts new_reservation.print_reservations(dates)
+# checkin_date = Date.new(2001,01,30)
+# checkout_date = Date.new(2001,02,2)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+# new_reservation.make_reservation("suyi", 3, dates)
+
+# puts
+# puts
+##TESTING FOR OVERLAP
+# checkin_date = Date.new(2001,02,2)
+# checkout_date = Date.new(2001,02,10)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+# puts
+# puts new_reservation.room_available(1,dates)
+# puts new_reservation.make_reservation("bob", 1, dates)
+# puts new_reservation.collection_of_reservations
+#
+#
+# checkin_date = Date.new(2001,02,3)
+# checkout_date = Date.new(2001,02,7)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+# puts new_reservation.room_available(1,dates)
+# #
+# checkin_date = Date.new(2001,02,3)
+# checkout_date = Date.new(2001,02,14)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+# puts new_reservation.room_available(1,dates)
+# puts
+# checkin_date = Date.new(2001,01,3)
+# checkout_date = Date.new(2001,01,7)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+# puts new_reservation.room_available(1,dates)
+# puts
+# puts
+#
+# checkin_date = Date.new(2017,01,3)
+# checkout_date = Date.new(2017,01,7)
+# dates = Hotel::DateRange.new(checkin_date, checkout_date)
+#
+# rooms = [2,3,4,5,6]
+
+# puts new_reservation.reserve_block_rooms(dates, rooms)
+=======
+>>>>>>> 81b14087aa1e4a11764bcae28888d634dd8d6e74

lib/date_range.rb

@@ -0,0 +1,58 @@
+require 'date'
+
+module Hotel
+  class DateRange
+    attr_reader :checkin_date, :checkout_date
+
+    # Checkin and checkout dates are instances of the Date class
+    def initialize(checkin_date, checkout_date)
+      if !checkin_date.is_a?(Date) || !checkout_date.is_a?(Date)
+        raise ArgumentError.new("Checkin or Checkout dates is not Date object")
+      end
+
+      if checkin_date > checkout_date
+        raise ArgumentError.new("Checkin date must be before Checkout date")
+      end
+
+      @checkin_date = checkin_date
+      @checkout_date = checkout_date
+    end
+
+    # check if reservation date request is within date range.
+    def date_include?(date_range)
+      # if date >= @checkin_date && date <= @checkout_date
+      start_date = date_range.checkin_date
+      end_date = date_range.checkout_date
+
+      if start_date >= @checkin_date && end_date <= @checkout_date
+        return true
+      else
+        return false
+      end
+    end
+
+    # check if the room is overbooked
+    def date_overlap?(date_range)
+      #(@checkin_date - end_date) * (start_date - @checkout_date) >= 0
+      # Will this method work?
+      start_date = date_range.checkin_date
+      end_date = date_range.checkout_date
+
+      if (start_date <= @checkout_date) && (end_date > @checkin_date)
+        return true
+      else
+        return false
+        # raise ArgumentError.new("#{start_date} and #{end_date} are outside the date range")
+      end
+    end
+
+  end #end of class
+end #end of module
+
+
+#### TESTING ##########
+
+# checkin_date = 2001,2,3
+# checkout_date = 2001,2,14
+# date =  Hotel::DateRange.new(checkin_date, checkout_date)
+# puts date.date_include?(2001,2,5)

lib/hotel.rb

@@ -0,0 +1,9 @@
+require_relative 'booking_system.rb'
+require_relative 'date_range.rb'
+require_relative 'reservation.rb'
+require_relative 'room.rb'
+require 'date'
+
+module Hotel
+
+end