Merge branch 'feature/scheduled_sessions' of bitbucket.org:jamkazam/jam-cloud into feature/scheduled_sessions

ruby/lib/jam_ruby/models/active_music_session.rb

@@ -314,6 +314,105 @@ module JamRuby
       return query
     end
 
+    def self.participant_create user, music_session_id, client_id, as_musician, tracks
+      music_session = MusicSession.find(music_session_id)
+
+      if music_session.active_music_session
+        connection = nil
+        active_music_session = nil
+        ActiveRecord::Base.transaction do
+
+          active_music_session = ActiveMusicSession.find(music_session_id)
+
+          active_music_session.with_lock do # VRFS-1297
+            active_music_session.tick_track_changes
+            connection = ConnectionManager.new.join_music_session(user, client_id, active_music_session, as_musician, tracks)
+
+            if connection.errors.any?
+              # rollback the transaction to make sure nothing is disturbed in the database
+              raise ActiveRecord::Rollback
+            end
+          end
+        end
+
+        unless connection.errors.any?
+          user.update_progression_field(:first_music_session_at)
+          MusicSessionUserHistory.save(music_session_id, user.id, client_id, tracks)
+
+          if as_musician
+            # send to session participants
+            Notification.send_session_join(active_music_session, connection, user)
+
+            # send "musician joined session" notification only if it's not a band session since there will be a "band joined session" notification
+            if music_session.band.nil?
+              Notification.send_musician_session_join(active_music_session, user)
+            end
+          end
+        end
+
+        connection
+      else
+        return_value = nil
+
+        time = Benchmark.realtime do
+          ActiveRecord::Base.transaction do
+
+            # we need to lock the icecast server in this transaction for writing, to make sure thath IcecastConfigWriter
+            # doesn't dumpXML as we are changing the server's configuraion
+            icecast_server = IcecastServer.find_best_server_for_user(user) if music_session.fan_access
+            icecast_server.lock! if icecast_server
+
+            # check if we are connected to rabbitmq
+            active_music_session = ActiveMusicSession.new
+            active_music_session.id = music_session.id # copy the .id from music_session to active_music_session
+            active_music_session.creator = user
+
+            if music_session.fan_access
+              # create an icecast mount since regular users can listen in to the broadcast
+              active_music_session.mount = IcecastMount.build_session_mount(music_session, active_music_session, icecast_server)
+            end
+
+            active_music_session.save
+
+            unless active_music_session.errors.any?
+              # save session parameters for next session
+              User.save_session_settings(user, music_session)
+
+              # auto-join this user into the newly created session
+              as_musician = true
+              connection = ConnectionManager.new.join_music_session(user, client_id, active_music_session, as_musician, tracks)
+
+              unless connection.errors.any?
+                user.update_progression_field(:first_music_session_at)
+                MusicSessionUserHistory.save(active_music_session.id, user.id, client_id, tracks)
+
+                # only send this notification if it's a band session
+                unless music_session.band.nil?
+                  Notification.send_band_session_join(active_music_session, music_session.band)
+                end
+
+                return_value = connection
+              else
+                return_value = connection
+                # rollback the transaction to make sure nothing is disturbed in the database
+                raise ActiveRecord::Rollback
+              end
+            else
+              return_value = active_music_session
+              # rollback the transaction to make sure nothing is disturbed in the database
+              raise ActiveRecord::Rollback
+            end
+          end
+        end
+
+        if time > 2
+          Logging.logger[self].warn "creating a music session took #{time*1000} milliseconds"
+        end
+
+        return_value
+      end
+    end
+
     # Verifies that the specified user can join this music session
     def can_join? user, as_musician
       if as_musician

ruby/lib/jam_ruby/models/music_session.rb

@@ -107,6 +107,15 @@ module JamRuby
       return query
     end
 
+    def self.scheduled user
+      current_time = Time.now
+      query = MusicSession.where("music_sessions.user_id = '#{user.id}'")
+      query = query.where("music_sessions.scheduled_start IS NOT NULL AND music_sessions.scheduled_start < '#{current_time + 12.hours}'")
+      query = query.order("music_sessions.scheduled_start ASC")
+
+      return query
+    end
+
     def self.create user, options
       band = Band.find(options[:band]) unless options[:band].nil?
 

web/app/assets/javascripts/jam_rest.js

@@ -59,6 +59,20 @@
           });
         }
 
+        function joinSession(options) {
+          var sessionId = options["session_id"];
+          delete options["session_id"];
+
+          return $.ajax({
+            type: "POST",
+            dataType: "json",
+            contentType: 'application/json',
+            url: "/api/sessions/" + sessionId + "/participants",
+            data: JSON.stringify(options),
+            processData: false
+          });
+        }
+
         function findSessions(query) {
           return $.ajax({
             type: "GET",
@@ -1007,6 +1021,7 @@
         this.initialize = initialize;
         this.legacyCreateSession = legacyCreateSession;
         this.legacyJoinSession = legacyJoinSession;
+        this.joinSession = joinSession;
         this.getUserDetail = getUserDetail;
         this.getCities = getCities;
         this.getRegions = getRegions;

web/app/assets/javascripts/sessionModel.js

@@ -371,7 +371,7 @@
                 session_id: sessionId
             };
 
-            return rest.legacyJoinSession(data);
+            return rest.joinSession(data);
         }
 
         function leaveSessionRest(sessionId) {

web/app/controllers/api_music_sessions_controller.rb

@@ -60,6 +60,10 @@ class ApiMusicSessionsController < ApiController
                                          limit: params[:limit])
   end
 
+  def scheduled
+    @music_sessions = MusicSession.scheduled(current_user)
+  end
+
   def create
     @music_session = MusicSession.create(current_user, params)
 
@@ -180,6 +184,34 @@ class ApiMusicSessionsController < ApiController
     end
   end
 
+  def participant_create
+    client_id = params[:client_id]
+
+    if client_id.nil?
+      raise JamArgumentError, "client_id must be asdfasfdasdf specified"
+    end
+
+    begin
+      @connection = ActiveMusicSession.participant_create(
+          current_user,
+          params[:id],
+          params[:client_id],
+          params[:as_musician],
+          params[:tracks]
+      )
+
+      if @connection.errors.any?
+        response.status = :unprocessable_entity
+        respond_with @connection
+      else
+        respond_with @connection, responder: ApiResponder, :location => api_session_participant_detail_url(@connection.client_id)
+      end
+
+    rescue ActiveRecord::RecordNotFound
+      render :json => { :message => ValidationMessages::SESSION_NOT_FOUND }, :status => 404
+    end
+  end
+
   def participant_delete
     client_id = params[:id]
     if client_id.present? && client_id != 'undefined'
@@ -379,7 +411,7 @@ class ApiMusicSessionsController < ApiController
     end
   end
 
-    def history_show
+  def show_history
     @history = MusicSession.find(params[:id])
   end
 

web/app/views/api_music_sessions/create.rabl

@@ -1 +1,3 @@
-object @music_session
+object @music_session
+
+extends "api_music_sessions/show_history"

web/app/views/api_music_sessions/scheduled.rabl

@@ -0,0 +1,3 @@
+object @music_sessions
+
+extends "api_music_sessions/show_history"

web/app/views/api_music_sessions/show_history.rabl

@@ -17,7 +17,7 @@ if !current_user
 else
 
   attributes :id, :music_session_id, :description, :musician_access, :approval_required, :fan_access, :fan_chat,
-   :band_id, :user_id, :genre_id, :created_at, :like_count, :comment_count
+   :band_id, :user_id, :genre_id, :created_at, :like_count, :comment_count, :scheduled_start, :scheduled_duration
 
   node :share_url do |history|
     unless history.share_token.nil?

web/config/routes.rb

@@ -145,8 +145,10 @@ SampleApp::Application.routes.draw do
 
     # music sessions
     match '/sessions/:id/participants/legacy' => 'api_music_sessions#participant_create_legacy', :via => :post  # can be removed when new Create Session comes in
+    match '/sessions/:id/participants' => 'api_music_sessions#participant_create', :via => :post
     match '/participants/:id' => 'api_music_sessions#participant_show', :via => :get, :as => 'api_session_participant_detail'
     match '/participants/:id' => 'api_music_sessions#participant_delete', :via => :delete
+    match '/sessions/scheduled' => 'api_music_sessions#scheduled', :via => :get
     match '/sessions/:id' => 'api_music_sessions#show', :via => :get, :as => 'api_session_detail'
     match '/sessions/:id' => 'api_music_sessions#update', :via => :put
     match '/sessions' => 'api_music_sessions#index', :via => :get
@@ -156,7 +158,7 @@ SampleApp::Application.routes.draw do
     match '/sessions/:id/perf' => 'api_music_sessions#perf_upload', :via => :put
     match '/sessions/:id/comments' => 'api_music_sessions#add_comment', :via => :post
     match '/sessions/:id/likes' => 'api_music_sessions#add_like', :via => :post
-    match '/sessions/:id/history' => 'api_music_sessions#history_show', :via => :get
+    match '/sessions/:id/history' => 'api_music_sessions#show_history', :via => :get, :as => 'api_session_history_detail'
     
     # music session tracks
     match '/sessions/:id/tracks' => 'api_music_sessions#track_create', :via => :post

web/spec/requests/active_music_sessions_api_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Music Session API ", :type => :api do
+describe "Active Music Session API ", :type => :api do
 
   include Rack::Test::Methods
 
@@ -23,7 +23,15 @@ describe "Music Session API ", :type => :api do
     let(:user) { FactoryGirl.create(:user) }
 
     # defopts are used to setup default options for the session
-    let(:defopts) { { :description => "a session", :fan_chat => true, :fan_access => true, :approval_required => false, :genres => ["classical"], :musician_access => true, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}], :legal_terms => true, :intellectual_property => true} }
+    let(:defopts) { { :name => "session name", :description => "session description",
+                      :genres => ["classical"], :musician_access => true, :approval_required => false,
+                      :fan_chat => true, :fan_access => true,
+                      :legal_policy => true, :language => 'english',
+                      :timezone => "utc"} }
+    let(:defpart) { { :as_musician => true,
+                      :tracks => [{"instrument_id" => "electric guitar",
+                                   "sound" => "mono",
+                                   "client_track_id" => "client_track_guid"}] } }
     before do
       #sign_in user
       ActiveMusicSession.delete_all
@@ -38,13 +46,12 @@ describe "Music Session API ", :type => :api do
 
     it "should create session" do
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1", :client_id => "1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
       # now fetch it's data
-      location_header = last_response.headers["Location"]
-      get location_header
       music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants", defpart.merge({ :client_id => client.client_id, }).to_json, "CONTENT_TYPE" => 'application/json'
 
       get '/api/sessions.json'
       music_sessions = JSON.parse(last_response.body)
@@ -184,14 +191,16 @@ describe "Music Session API ", :type => :api do
     it "should add/remove member from session" do
       # create the session
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
       # now fetch it's data
-      location_header = last_response.headers["Location"]
-      get location_header + ".json", "CONTENT_TYPE" => 'application/json'
-
       music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants", defpart.merge({ :client_id => client.client_id, }).to_json, "CONTENT_TYPE" => 'application/json'
+
+      get "/api/sessions.json", "CONTENT_TYPE" => 'application/json'
+
+      music_session = JSON.parse(last_response.body)[0]
 
       # and the creator should be in the session
       music_session["participants"].length.should == 1
@@ -219,14 +228,16 @@ describe "Music Session API ", :type => :api do
       user2 = FactoryGirl.create(:user)
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
       client2 = FactoryGirl.create(:connection, :user => user2, :ip_address => "2.2.2.2")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
       # now fetch it's data
-      music_session_uri = last_response.headers["Location"]
-      get music_session_uri + ".json", "CONTENT_TYPE" => 'application/json'
-
       music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants", defpart.merge({ :client_id => client.client_id, }).to_json, "CONTENT_TYPE" => 'application/json'
+
+      get "/api/sessions.json", "CONTENT_TYPE" => 'application/json'
+
+      music_session = JSON.parse(last_response.body)[0]
 
       # and the creator should be in the session
       music_session["participants"].length.should == 1
@@ -239,8 +250,7 @@ describe "Music Session API ", :type => :api do
       musician["client_id"].should == client.client_id
 
       login(user2)
-      post "/api/sessions/#{music_session["id"]}/participants/legacy.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
-
+      post "/api/sessions/#{music_session["id"]}/participants.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
       # now fetch it's data
@@ -260,9 +270,9 @@ describe "Music Session API ", :type => :api do
 
       # refetch the session and make sure both participnats are accounted for
       login(user2)
-      get music_session_uri + ".json", "CONTENT_TYPE" => 'application/json'
+      get "/api/sessions.json", "CONTENT_TYPE" => 'application/json'
 
-      music_session = JSON.parse(last_response.body)
+      music_session = JSON.parse(last_response.body)[0]
       # and the creator should be in the session
       music_session["participants"].length.should == 2
 
@@ -284,14 +294,14 @@ describe "Music Session API ", :type => :api do
       # create the session
       original_count = ActiveMusicSession.all().length
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :genres => nil}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.merge({:genres => nil}).to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(422)
       ActiveMusicSession.all().length.should == original_count
     end
 
     it "should error with invalid genre specified" do
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({ :client_id => client.client_id, :genres => ["Junk"]}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.merge({:genres => ["Junk"]}).to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(422)
       JSON.parse(last_response.body)["errors"]["genre"].should == ["can't be blank"]
     end
@@ -300,8 +310,12 @@ describe "Music Session API ", :type => :api do
       original_count = ActiveMusicSession.all().length
 
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :tracks => nil}).to_json, "CONTENT_TYPE" => 'application/json'
-      last_response.status.should eql(422)
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants.json", {  :client_id => client.client_id, :as_musician => true, :tracks => []}.to_json, "CONTENT_TYPE" => 'application/json'
+
       JSON.parse(last_response.body)["errors"]["tracks"].should == [ValidationMessages::SELECT_AT_LEAST_ONE]
 
       # check that the transaction was rolled back
@@ -312,7 +326,12 @@ describe "Music Session API ", :type => :api do
       original_count = ActiveMusicSession.all().length
 
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :tracks => [{"instrument_id" => "mom", "sound" => "mono", "client_track_id" => "client_track_guid"}]}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      # now fetch it's data
+      music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants", defpart.merge({ :client_id => client.client_id, :tracks => [{"instrument_id" => "mom", "sound" => "mono", "client_track_id" => "client_track_guid"}] }).to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(404)
 
       # check that the transaction was rolled back
@@ -323,10 +342,13 @@ describe "Music Session API ", :type => :api do
       original_count = ActiveMusicSession.all().length
 
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mom", "client_track_id" => "client_track_guid"}]}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
 
-      last_response.status.should eql(422)
-      JSON.parse(last_response.body)["errors"]["tracks"][0].should == "is invalid"
+      # now fetch it's data
+      music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants", defpart.merge({ :client_id => client.client_id, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mom", "client_track_id" => "client_track_guid"}] }).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(406)
 
       # check that the transaction was rolled back
       ActiveMusicSession.all().length.should == original_count
@@ -367,9 +389,18 @@ describe "Music Session API ", :type => :api do
       user2 = FactoryGirl.create(:user) # in the music session
 
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :musician_access => false}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
-      session = JSON.parse(last_response.body)
+
+      # now fetch it's data
+      music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      get '/api/sessions.json'
+      last_response.status.should eql(200)
+      music_sessions = JSON.parse(last_response.body)
+      session = music_sessions[0]
 
       FactoryGirl.create(:friendship, :user => user, :friend => user2)
       FactoryGirl.create(:friendship, :user => user2, :friend => user)
@@ -381,7 +412,7 @@ describe "Music Session API ", :type => :api do
       music_sessions = JSON.parse(last_response.body)
       music_session = music_sessions[0]
       music_session["id"].should == session["id"]
-      music_session["musician_access"].should == false
+      music_session["musician_access"].should == true
 
       # we should be able to see the invitation
       music_session["invitations"].length.should == 1
@@ -401,7 +432,13 @@ describe "Music Session API ", :type => :api do
       user2 = FactoryGirl.create(:user) # in the music session
 
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1", :client_id => "3")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :musician_access => false}).to_json, "CONTENT_TYPE" => 'application/json'
+      login(user)
+      post '/api/sessions.json', defopts.merge({:musician_access => false}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+      # now fetch it's data
+      music_session = JSON.parse(last_response.body)
+
+      post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
       session = JSON.parse(last_response.body)
 
@@ -411,31 +448,32 @@ describe "Music Session API ", :type => :api do
       FactoryGirl.create(:friendship, :user => user2, :friend => user)
 
       # users are friends, but no invitation... so we shouldn't be able to join as user 2
+
       login(user2)
-      post "/api/sessions/#{session["id"]}/participants/legacy.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}] }.to_json,  "CONTENT_TYPE" => 'application/json'
+      post "/api/sessions/#{session["music_session_id"]}/participants.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(422)
       join_response = JSON.parse(last_response.body)
       join_response["errors"]["musician_access"].should == [ValidationMessages::INVITE_REQUIRED]
 
       # but let's make sure if we then invite, that we can then join'
       login(user)
-      post '/api/invitations.json', { :music_session => session["id"], :receiver => user2.id }.to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/invitations.json', { :music_session => session["music_session_id"], :receiver => user2.id }.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
       login(user2)
-      post "/api/sessions/#{session["id"]}/participants/legacy.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}] }.to_json, "CONTENT_TYPE" => 'application/json'
+      post "/api/sessions/#{session["music_session_id"]}/participants.json", { :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}] }.to_json, "CONTENT_TYPE" => 'application/json'
             
       last_response.status.should eql(201)
     end
 
     it "join_requests don't show up in session listing" do
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
-      location_header = last_response.headers["Location"]
-      get location_header
       music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
 
       get '/api/sessions.json'
       music_sessions = JSON.parse(last_response.body)
@@ -480,20 +518,22 @@ describe "Music Session API ", :type => :api do
 
     it "should now allow join of approval_required=true session" do
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :approval_required => true}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.merge({:approval_required => true}).to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
-      # now fetch it's data
-      location_header = last_response.headers["Location"]
-      get location_header
       music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      get "/api/sessions.json"
+      music_session = JSON.parse(last_response.body)[0]
 
       # try to add 2nd user to session - should fail because approval is required
       user2 = FactoryGirl.create(:user)
       client2 = FactoryGirl.create(:connection, :user => user2, :ip_address => "2.2.2.2")
 
       login(user2)
-      post "/api/sessions/#{music_session["id"]}/participants/legacy.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
+      post "/api/sessions/#{music_session["id"]}/participants.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(422)
       rejected_join_attempt = JSON.parse(last_response.body)
       rejected_join_attempt["errors"]["approval_required"] = [ValidationMessages::INVITE_REQUIRED]
@@ -515,7 +555,7 @@ describe "Music Session API ", :type => :api do
 
       # finally, go back to user2 and attempt to join again
       login(user2)
-      post "/api/sessions/#{music_session["id"]}/participants/legacy.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
+      post "/api/sessions/#{music_session["id"]}/participants.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "bass guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
     end
 
@@ -527,13 +567,15 @@ describe "Music Session API ", :type => :api do
       # https://jamkazam.atlassian.net/browse/VRFS-254
       user.admin = true
       client = FactoryGirl.create(:connection, :user => user)
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
 
-      # now fetch it's data
-      location_header = last_response.headers["Location"]
-      get location_header
       music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      get "/api/sessions.json"
+      music_session = JSON.parse(last_response.body)[0]
 
       get "/api/sessions/#{music_session["id"]}.json"
       last_response.status.should eql(200)
@@ -545,7 +587,7 @@ describe "Music Session API ", :type => :api do
       track["instrument_id"].should == "electric guitar"
       track["sound"].should == "mono"
 
-      post "/api/sessions/#{music_session["id"]}/participants/legacy.json", {  :client_id => client.client_id, :as_musician => true, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
+      post "/api/sessions/#{music_session["id"]}/participants.json", {  :client_id => client.client_id, :as_musician => true, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
 
       last_response.status.should eql(201)
 
@@ -571,10 +613,14 @@ describe "Music Session API ", :type => :api do
 
       # 1st user joins
       login(user)
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
-      location_header = last_response.headers["Location"]
-      get location_header
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
+
       music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      get "/api/sessions.json"
+      music_session = JSON.parse(last_response.body)[0]
 
       # start a recording
       post "/api/recordings/start", {:format => :json, :music_session_id => music_session['id'] }.to_json, "CONTENT_TYPE" => 'application/json'
@@ -582,7 +628,7 @@ describe "Music Session API ", :type => :api do
 
       # user 2 should not be able to join
       login(user2)
-      post "/api/sessions/#{music_session["id"]}/participants/legacy.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
+      post "/api/sessions/#{music_session["id"]}/participants.json", {  :client_id => client2.client_id, :as_musician => true, :tracks => [{"instrument_id" => "electric guitar", "sound" => "mono", "client_track_id" => "client_track_guid"}]}.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(422)
       JSON.parse(last_response.body)["errors"]["music_session"][0].should == ValidationMessages::CANT_JOIN_RECORDING_SESSION
     end
@@ -592,9 +638,16 @@ describe "Music Session API ", :type => :api do
       server = FactoryGirl.create(:icecast_server_minimal)
       user2 = FactoryGirl.create(:user) # in the music session
       client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.10", :client_id => "mount_info")
-      post '/api/sessions/legacy.json', defopts.merge({:client_id => client.client_id, :fan_access => true}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.merge({:fan_access => true}).to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
-      session = JSON.parse(last_response.body)
+
+      music_session = JSON.parse(last_response.body)
+      post "/api/sessions/#{music_session["id"]}/participants.json", defpart.merge({ :client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      get "/api/sessions.json"
+      session = JSON.parse(last_response.body)[0]
+
       music_session = ActiveMusicSession.find(session["id"])
       session["mount"].should_not be_nil
       session["mount"]["name"].should == music_session.mount.name
@@ -723,8 +776,4 @@ describe "Music Session API ", :type => :api do
     music_session.claimed_recording.should be_nil
     music_session.claimed_recording_initiator.should be_nil
   end
-end
-
-
-
-
+end

web/spec/requests/music_sessions_api_spec.rb

@@ -33,9 +33,37 @@ describe "Scheduled Music Session API ", :type => :api do
     end
 
     it "should create session" do
-      client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.1", :client_id => "1")
-      post '/api/sessions.json', defopts.merge({:client_id => client.client_id}).to_json, "CONTENT_TYPE" => 'application/json'
+      post '/api/sessions.json', defopts.to_json, "CONTENT_TYPE" => 'application/json'
       last_response.status.should eql(201)
+
+      music_session = JSON.parse(last_response.body)
+      music_session[:name] = defopts[:name]
+      music_session[:description] = defopts[:description]
+      music_session[:musician_access] = defopts[:musician_access]
+      music_session[:fan_chat] = defopts[:fan_chat]
+      music_session[:fan_access] = defopts[:fan_access]
+      music_session[:language] = defopts[:language]
+      music_session[:timezone] = defopts[:timezone]
+    end
+
+    it "should list scheduled sessions" do
+      login(user)
+
+      post '/api/sessions.json', defopts.merge({start: Time.now + 3.hours}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      post '/api/sessions.json', defopts.merge({start: Time.now + 7.hours}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      post '/api/sessions.json', defopts.merge({start: Time.now + 15.hours}).to_json, "CONTENT_TYPE" => 'application/json'
+      last_response.status.should eql(201)
+
+      get '/api/sessions/scheduled.json'
+      last_response.status.should eql(200)
+      music_sessions = JSON.parse(last_response.body)
+
+      music_sessions.count.should eql(2)
+      expect(Time.parse(music_sessions[0]["scheduled_start"]).to_i).to be < Time.parse(music_sessions[1]["scheduled_start"]).to_i
     end
   end
 end