jam-cloud/ruby/lib/jam_ruby/models/rsvp_request.rb

module JamRuby
  class RsvpRequest < ActiveRecord::Base

    belongs_to :user, :class_name => "JamRuby::User"
    has_many :rsvp_requests_rsvp_slots, :class_name => "JamRuby::RsvpRequestRsvpSlot", :foreign_key => "rsvp_request_id"
    has_many :rsvp_slots, :class_name => "JamRuby::RsvpSlot", :through => :rsvp_requests_rsvp_slots
    
    validates :canceled, :inclusion => {:in => [nil, true, false]}

    def self.index(music_session, user = nil)
      query = RsvpRequest
                .includes(:user)
                .joins(
                  %Q{
                    INNER JOIN
                      rsvp_requests_rsvp_slots rrrs
                    ON
                      rrrs.rsvp_request_id = rsvp_requests.id
                    INNER JOIN
                      rsvp_slots rs
                    ON rs.id = rrrs.rsvp_slot_id
                  }
                )
                .where(
                  %Q{
                    rs.music_session_id = '#{music_session.id}'
                  }
                )

      query = query.where("rsvp_requests.user_id = ?", user.id) unless user.nil?
      return query.uniq
    end

    def self.create(params, user)
      music_session = MusicSession.find_by_id(params[:session_id])

      # verify music session exists
      if music_session.nil?
        raise JamRuby::JamArgumentError.new("Invalid session.")
      end

      # verify invitation exists for this user and session
      invitation = Invitation.where("music_session_id = ? AND receiver_id = ?", music_session.id, user.id)

      if invitation.blank?
        raise PermissionError, "Only a session invitee can create an RSVP." 
      end

      # verify slot IDs exist in request
      if params[:rsvp_slots].blank?
        raise JamArgumentError, "You must select at least 1 slot."
      end

      RsvpRequest.transaction do
        @rsvp = RsvpRequest.new
        @rsvp.user = user
        
        slot_ids = params[:rsvp_slots]
        instruments = []

        # for each slot requested, do the following:
        # (1) verify slot exists in db
        # (2) verify slot is not already chosen
        # (3) create RsvpRequestRsvpSlot
        # (4) create RsvpRequest
        slot_ids.each do |id|
          rsvp_slot = RsvpSlot.where(:id => id).first

          # verify slot exists in db
          if rsvp_slot.nil?
            raise JamRuby::JamArgumentError.new("Invalid slot #{id}.")
          end

          chosen_slot = rsvp_slot.rsvp_requests_rsvp_slots.where("chosen = true").first

          # verify this slot was not already chosen
          if !chosen_slot.nil?
            raise JamRuby::JamArgumentError.new("The #{rsvp_slot.instrument_id} slot has already been approved by the session organizer.")
          else
            rsvp_request_rsvp_slot = RsvpRequestRsvpSlot.new
            rsvp_request_rsvp_slot.rsvp_request = @rsvp
            rsvp_request_rsvp_slot.rsvp_slot = rsvp_slot
            rsvp_request_rsvp_slot.save

            instruments << rsvp_slot.instrument_id
          end
        end

        @rsvp.save

        unless params[:message].blank?
          session_info_comment = SessionInfoComment.new
          session_info_comment.music_session = music_session
          session_info_comment.user = user
          session_info_comment.comment = params[:message]
          session_info_comment.save
        end

        Notification.send_scheduled_session_rsvp(music_session, user, instruments)
        Notification.send_scheduled_session_comment(music_session, user, params[:message])

        @rsvp
      end
    end

    def self.update(params, user)

      rsvp_request_id = params[:id]

      music_session = MusicSession.find(params[:session_id])

      # verify music session exists
      if music_session.nil?
        raise JamRuby::JamArgumentError.new("Invalid session.")
      end

      # authorize the user attempting to respond to the RSVP request
      if music_session.creator.id != user.id
        raise PermissionError, "Only the session organizer can accept or decline and RSVP request." 
      end

      RsvpRequest.transaction do
        if !params[:rsvp_response].blank?
          
          instruments = []

          responses = params[:rsvp_response]
          responses.each do |r|
            if r.accept
              request_slot = RsvpRequestRsvpSlot.find(r.request_slot_id)
              request_slot.chosen = true
              request_slot.save

              rsvp_slot = RsvpSlot.find(request_slot.rsvp_slot_id)
              instruments << rsvp_slot.instrument_id
            end
          end

          Notification.send_scheduled_session_rsvp_approved(music_session, user, instruments)

        else
          raise JamRuby::JamArgumentError.new("Invalid request.")
        end
      end
    end

    def self.cancel(rsvp_request, music_session, user, message)
      if music_session.creator.id != user.id && rsvp_request.user_id != user.id
        raise PermissionError, "Only the session organizer or RSVP creator can cancel the RSVP."
      end

      RsvpRequest.transaction do

        # mark corresponding slot's chosen field as false
        rsvp_request_slots = RsvpRequestRsvpSlot.find("rsvp_request_id = ?", rsvp_request.id)

        rsvp_request_slots.each do |slot|
          if slot.chosen
            slot.chosen = false
            slot.save
          end
        end

        # send notification
        if music_session.creator.id == user.id
          Notification.send_scheduled_session_rsvp_cancelled_org(music_session, user)
        else
          Notification.send_scheduled_session_rsvp_cancelled(music_session, user)
        end

        Notification.send_scheduled_session_comment(music_session, user, message)
      end
    end
  end

end