diff --git a/admin/Gemfile b/admin/Gemfile index 756225a1a..1a1a7c248 100644 --- a/admin/Gemfile +++ b/admin/Gemfile @@ -44,7 +44,7 @@ gem 'rails3-jquery-autocomplete' gem 'activeadmin' #, github: 'activeadmin', branch: '0-6-stable' gem 'mime-types', '1.25' gem 'meta_search' -gem 'fog', "~> 1.32.0" +gem 'fog' gem 'unf', '0.1.3' #optional fog dependency gem 'country-select' gem 'aasm', '3.0.16' diff --git a/admin/app/admin/download_tracker.rb b/admin/app/admin/download_tracker.rb new file mode 100644 index 000000000..2577736e5 --- /dev/null +++ b/admin/app/admin/download_tracker.rb @@ -0,0 +1,34 @@ +ActiveAdmin.register JamRuby::DownloadTracker, :as => 'DownloadTrackers' do + + menu :label => 'Download Trackers', :parent => 'JamTracks' + + config.batch_actions = false + config.filters = true + config.per_page = 50 + + filter :remote_ip + + index do + column 'User' do |oo| oo.user ? link_to(oo.user.email, oo.user.admin_url, {:title => oo.user.email}) : '' end + column 'Remote IP' do |oo| oo.remote_ip end + column 'JamTrack' do |oo| oo.jam_track end + column 'Paid' do |oo| oo.paid end + column 'Blacklisted?' do |oo| IpBlacklist.listed(oo.remote_ip) ? 'Yes' : 'No' end + column "" do |oo| + link_to 'Blacklist This IP', "download_trackers/#{oo.id}/blacklist_by_ip" + end + end + + member_action :blacklist_by_ip, :method => :get do + tracker = DownloadTracker.find(params[:id]) + + if !IpBlacklist.listed(tracker.remote_ip) + ip = IpBlacklist.new + ip.remote_ip = tracker.remote_ip + ip.save! + end + + redirect_to admin_download_trackers_path, :notice => "IP address #{tracker.remote_ip} blacklisted." + end + +end diff --git a/admin/app/admin/fake_purchaser.rb b/admin/app/admin/fake_purchaser.rb index b8c5caa31..87d167330 100644 --- a/admin/app/admin/fake_purchaser.rb +++ b/admin/app/admin/fake_purchaser.rb @@ -32,6 +32,7 @@ ActiveAdmin.register_page "Fake Purchaser" do jam_track_right.user = user jam_track_right.jam_track = jam_track jam_track_right.is_test_purchase = true + jam_track_right.version = jam_track.version jam_track_right.save! count = count + 1 end diff --git a/admin/app/admin/gift_card_upload.rb b/admin/app/admin/gift_card_upload.rb new file mode 100644 index 000000000..87e69850e --- /dev/null +++ b/admin/app/admin/gift_card_upload.rb @@ -0,0 +1,41 @@ +ActiveAdmin.register_page "Giftcarduploads" do + + menu :label => 'Gift Cards Upload', :parent => 'JamTracks' + + page_action :upload_giftcards, :method => :post do + GiftCard.transaction do + + puts params + + file = params[:jam_ruby_gift_card][:csv] + array_of_arrays = CSV.read(file.tempfile.path) + array_of_arrays.each do |row| + if row.length != 1 + raise "UKNONWN CSV FORMAT! Must be 1 column" + end + + code = row[0] + + gift_card = GiftCard.new + gift_card.code = code + gift_card.card_type = params[:jam_ruby_gift_card][:card_type] + gift_card.origin = file .original_filename + gift_card.save! + end + + redirect_to admin_giftcarduploads_path, :notice => "Created #{array_of_arrays.length} gift cards!" + end + end + + content do + semantic_form_for GiftCard.new, :url => admin_giftcarduploads_upload_giftcards_path, :builder => ActiveAdmin::FormBuilder do |f| + f.inputs "Upload Gift Cards" do + f.input :csv, as: :file, required: true, :label => "A single column CSV that contains ONE type of gift card (5 JamTrack, 10 JamTrack, etc)" + f.input :card_type, required:true, as: :select, :collection => JamRuby::GiftCard::CARD_TYPES + end + f.actions + end + end + +end + diff --git a/admin/app/admin/gift_cards.rb b/admin/app/admin/gift_cards.rb new file mode 100644 index 000000000..8e1d4e80d --- /dev/null +++ b/admin/app/admin/gift_cards.rb @@ -0,0 +1,24 @@ +ActiveAdmin.register JamRuby::GiftCard, :as => 'GiftCards' do + + menu :label => 'Gift Cards', :parent => 'JamTracks' + + config.batch_actions = false + config.filters = true + config.per_page = 50 + + scope("Redeemed Most Recently", default: true) { |scope| scope.where('user_id IS NOT NULL').order('updated_at DESC') } + scope("Available") { |scope| scope.where('user_id is NULL') } + + filter :card_type + filter :origin + filter :code + + index do + column 'User' do |oo| oo.user ? link_to(oo.user.email, oo.user.admin_url, {:title => oo.user.email}) : '' end + column 'Code' do |oo| oo.code end + column 'Card Type' do |oo| oo.card_type end + column 'Origin' do |oo| oo.origin end + column 'Created' do |oo| oo.created_at end + end + +end diff --git a/admin/app/admin/jam_tracks.rb b/admin/app/admin/jam_tracks.rb index 534b65903..4a039e32f 100644 --- a/admin/app/admin/jam_tracks.rb +++ b/admin/app/admin/jam_tracks.rb @@ -11,7 +11,8 @@ ActiveAdmin.register JamRuby::JamTrack, :as => 'JamTracks' do scope("Default", default: true) { |scope| scope } scope("Onboarding TODO") { |scope| scope.where('onboarding_exceptions is not null') } scope("Tency Only") { |scope| scope.joins('INNER JOIN jam_track_licensors as licensors ON jam_tracks.licensor_id = licensors.id').where("licensors.name = 'Tency Music'") } - scope("Onboarding TODO w/ Tency Only") { |scope| scope.joins('INNER JOIN jam_track_licensors as licensors ON jam_tracks.licensor_id = licensors.id').where("licensors.name = 'Tency Music'").where('onboarding_exceptions is not null') } + scope("TimTracks Only") { |scope| scope.joins('INNER JOIN jam_track_licensors as licensors ON jam_tracks.licensor_id = licensors.id').where("licensors.name = 'Tim Waurick'") } + # scope("Onboarding TODO w/ Tency Only") { |scope| scope.joins('INNER JOIN jam_track_licensors as licensors ON jam_tracks.licensor_id = licensors.id').where("licensors.name = 'Tency Music'").where('onboarding_exceptions is not null') } form :partial => 'form' diff --git a/admin/app/controllers/email_controller.rb b/admin/app/controllers/email_controller.rb index 1e0c55182..4c999fd30 100644 --- a/admin/app/controllers/email_controller.rb +++ b/admin/app/controllers/email_controller.rb @@ -15,5 +15,11 @@ class EmailController < ApplicationController headers['Content-Type'] ||= 'text/csv' @users = User.where(subscribe_email: true) + + # if specified, return only users that have redeemed or bought a JamTrack + if params[:any_jam_track] + @users = @users.select('DISTINCT users.id, email, first_name, last_name').joins(:sales => :sale_line_items).where("sale_line_items.product_type = 'JamTrack'") + end + end end \ No newline at end of file diff --git a/admin/app/views/admin/jam_tracks/_form.html.slim b/admin/app/views/admin/jam_tracks/_form.html.slim index 334cdc27e..ac038e5ca 100644 --- a/admin/app/views/admin/jam_tracks/_form.html.slim +++ b/admin/app/views/admin/jam_tracks/_form.html.slim @@ -13,6 +13,7 @@ = f.input :publisher, :input_html => { :rows=>1, :maxlength=>1000 } = f.input :licensor, collection: JamRuby::JamTrackLicensor.all, include_blank: true = f.input :genres + = f.input :year = f.input :duration, hint: 'this should rarely need editing because it comes from the import process' = f.input :sales_region, collection: JamRuby::JamTrack::SALES_REGION, include_blank: false = f.input :price, :required => true, :input_html => {type: 'numeric'} diff --git a/admin/config/initializers/gift_cards.rb b/admin/config/initializers/gift_cards.rb new file mode 100644 index 000000000..8c967ccb4 --- /dev/null +++ b/admin/config/initializers/gift_cards.rb @@ -0,0 +1,9 @@ +class JamRuby::GiftCard + + attr_accessor :csv + + + def process_csv + + end +end diff --git a/admin/config/initializers/jam_tracks.rb b/admin/config/initializers/jam_tracks.rb index 33efd995c..60537c467 100644 --- a/admin/config/initializers/jam_tracks.rb +++ b/admin/config/initializers/jam_tracks.rb @@ -2,28 +2,5 @@ class JamRuby::JamTrack # add a custom validation - attr_accessor :preview_generate_error - before_save :jmep_json_generate - validate :jmep_text_validate - - def jmep_text_validate - begin - JmepManager.execute(self.jmep_text) - rescue ArgumentError => err - errors.add(:jmep_text, err.to_s) - end - end - - def jmep_json_generate - self.licensor_id = nil if self.licensor_id == '' - self.jmep_json = nil if self.jmep_json == '' - self.time_signature = nil if self.time_signature == '' - - begin - self[:jmep_json] = JmepManager.execute(self.jmep_text) - rescue ArgumentError => err - #errors.add(:jmep_text, err.to_s) - end - end end diff --git a/db/manifest b/db/manifest index 4da7a1b28..c75998c34 100755 --- a/db/manifest +++ b/db/manifest @@ -310,3 +310,8 @@ web_playable_jamtracks.sql affiliate_partner_rate.sql track_downloads.sql jam_track_lang_idx.sql +giftcard.sql +add_description_to_crash_dumps.sql +acappella.sql +purchasable_gift_cards.sql +versionable_jamtracks.sql \ No newline at end of file diff --git a/db/up/acappella.sql b/db/up/acappella.sql new file mode 100644 index 000000000..cf17e052d --- /dev/null +++ b/db/up/acappella.sql @@ -0,0 +1,2 @@ +INSERT INTO genres (id, description) values ('acapella', 'A Capella'); +ALTER TABLE jam_track_licensors ADD COLUMN slug VARCHAR UNIQUE; diff --git a/db/up/add_description_to_crash_dumps.sql b/db/up/add_description_to_crash_dumps.sql new file mode 100644 index 000000000..e08540d85 --- /dev/null +++ b/db/up/add_description_to_crash_dumps.sql @@ -0,0 +1 @@ +ALTER TABLE crash_dumps ADD COLUMN description VARCHAR(20000); \ No newline at end of file diff --git a/db/up/giftcard.sql b/db/up/giftcard.sql new file mode 100644 index 000000000..eae33c13e --- /dev/null +++ b/db/up/giftcard.sql @@ -0,0 +1,13 @@ +CREATE TABLE gift_cards ( + id VARCHAR(64) PRIMARY KEY DEFAULT uuid_generate_v4(), + code VARCHAR(64) UNIQUE NOT NULL, + user_id VARCHAR (64) REFERENCES users(id) ON DELETE CASCADE, + card_type VARCHAR(64) NOT NULL, + origin VARCHAR(200), + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); + +CREATE INDEX gift_card_user_id_idx ON gift_cards(user_id); + +ALTER TABLE users ADD COLUMN gifted_jamtracks INTEGER DEFAULT 0; diff --git a/db/up/purchasable_gift_cards.sql b/db/up/purchasable_gift_cards.sql new file mode 100644 index 000000000..9ef8d29fa --- /dev/null +++ b/db/up/purchasable_gift_cards.sql @@ -0,0 +1,24 @@ + + +CREATE TABLE gift_card_types ( + id VARCHAR(64) PRIMARY KEY DEFAULT uuid_generate_v4(), + card_type VARCHAR(64) NOT NULL, + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); + +INSERT INTO gift_card_types (id, card_type) VALUES ('jam_tracks_5', 'jam_tracks_5'); +INSERT INTO gift_card_types (id, card_type) VALUES ('jam_tracks_10', 'jam_tracks_10'); + +CREATE TABLE gift_card_purchases ( + id VARCHAR(64) PRIMARY KEY DEFAULT uuid_generate_v4(), + user_id VARCHAR(64) NOT NULL REFERENCES users(id) ON DELETE SET NULL, + gift_card_type_id VARCHAR(64) REFERENCES gift_card_types(id) ON DELETE SET NULL, + recurly_adjustment_uuid VARCHAR(500), + recurly_adjustment_credit_uuid VARCHAR(500), + created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP +); + + +ALTER TABLE sale_line_items ADD COLUMN gift_card_purchase_id VARCHAR(64) REFERENCES gift_card_purchases(id); diff --git a/db/up/versionable_jamtracks.sql b/db/up/versionable_jamtracks.sql new file mode 100644 index 000000000..9751bb940 --- /dev/null +++ b/db/up/versionable_jamtracks.sql @@ -0,0 +1 @@ +ALTER TABLE jam_track_rights ADD COLUMN version VARCHAR NOT NULL DEFAULT '0'; \ No newline at end of file diff --git a/ruby/lib/jam_ruby.rb b/ruby/lib/jam_ruby.rb index 21e2446d9..b3772ec14 100755 --- a/ruby/lib/jam_ruby.rb +++ b/ruby/lib/jam_ruby.rb @@ -253,6 +253,9 @@ require "jam_ruby/models/musician_search" require "jam_ruby/models/band_search" require "jam_ruby/import/tency_stem_mapping" require "jam_ruby/models/jam_track_search" +require "jam_ruby/models/gift_card" +require "jam_ruby/models/gift_card_purchase" +require "jam_ruby/models/gift_card_type" include Jampb diff --git a/ruby/lib/jam_ruby/constants/validation_messages.rb b/ruby/lib/jam_ruby/constants/validation_messages.rb index 662fce608..e84dff7c3 100644 --- a/ruby/lib/jam_ruby/constants/validation_messages.rb +++ b/ruby/lib/jam_ruby/constants/validation_messages.rb @@ -19,6 +19,8 @@ module ValidationMessages # sessions SESSION_NOT_FOUND = "Session not found." + NOT_FOUND = 'not found' + # genres RECORDING_GENRE_LIMIT_EXCEEDED = "No more than 1 genre is allowed." BAND_GENRE_LIMIT_EXCEEDED = "No more than 3 genres are allowed." diff --git a/ruby/lib/jam_ruby/jam_track_importer.rb b/ruby/lib/jam_ruby/jam_track_importer.rb index a92aca61b..fed33d413 100644 --- a/ruby/lib/jam_ruby/jam_track_importer.rb +++ b/ruby/lib/jam_ruby/jam_track_importer.rb @@ -29,10 +29,187 @@ module JamRuby end def finish(reason, detail) + @@log.info("JamTrackImporter:#{self.name} #{reason}") self.reason = reason self.detail = detail end + def import_click_track(jam_track) + # we need to download the click track, if it exists. + Dir.mktmpdir do |tmp_dir| + + @@log.info("importing clicking track for #{jam_track.original_artist}:#{jam_track.name}") + + if jam_track.click_track + @@log.info("already has click track: #{jam_track.original_artist}:#{jam_track.name}") + finish('success', 'already_has_click_track') + return + end + + click_track_file = jam_track.click_track_file + if click_track_file.nil? + @@log.info("no click track for #{jam_track.original_artist}:#{jam_track.name}") + finish('success', 'no_click_track') + return + end + + original_filename = click_track_file[:original_filename] + + if original_filename.nil? + @@log.info("no click track s3 path for #{jam_track.original_artist}:#{jam_track.name}") + finish('no_original_source', 'click track is missing s3 path:' + click_track_file.id) + return + end + + #wav_file = File.join(tmp_dir, File.basename(click_track_file[:original_filename])) + #JamTrackImporter.song_storage_manager.download(click_track_file[:original_filename], wav_file) + + JamTrack.transaction do + click_track = jam_track.click_track + + if click_track.nil? + click_track = JamTrackTrack.new + click_track.original_filename = click_track_file[:original_filename] + click_track.original_audio_s3_path = click_track_file[:original_filename] + click_track.track_type = 'Click' + click_track.part = 'Clicktrack' + click_track.instrument_id = 'computer' + click_track.jam_track = jam_track + click_track.position = 10000 + if !click_track.save + @@log.error("unable to create jamtrack click track #{click_track.errors.inspect}") + finish("jam_track_click", "unable to create: #{click_track.errors.inspect}") + return false + end + end + + jam_track.increment_version! + + # with the click track in hand, flesh out the details + synchronize_audio_track(jam_track, tmp_dir, false, click_track) + + finish('success', nil) + end + end + end + + def generate_jmep(jam_track) + if !jam_track.blank? + finish('success', 'jmep already exists') + return + else + # we need to download the click track, if it exists. + Dir.mktmpdir do |tmp_dir| + + master_track = jam_track.master_track + + click_track = jam_track.click_track_file + + if master_track.nil? + finish('no_master_track', nil) + return + end + + master_track_file = File.join(tmp_dir, File.basename(master_track[:url_48])) + begin + JamTrackImporter.private_s3_manager.download(master_track.url_by_sample_rate(44), master_track_file) + rescue Exception => e + @@log.error("unable to download master track") + finish("no-download-master", master_track.url_by_sample_rate(44)) + return + end + + if click_track + click_track_file = File.join(tmp_dir, File.basename(click_track[:original_filename])) + JamTrackImporter.song_storage_manager.download(click_track[:original_filename], click_track_file) + else + # we'll use the master for click analysis. not ideal, but would work + click_track_file = master_track_file + end + + start_time = determine_start_time(master_track_file, tmp_dir, master_track[:url]) + + # bpm comes from git clone http://www.pogo.org.uk/~mark/bpm-tools.git + + sox="sox #{Shellwords.escape(click_track_file)} -t raw -r 44100 -e float -c 1 - | bpm" + cmd = "bash -c #{Shellwords.escape(sox)}" + @@log.debug("executing cmd #{cmd}") + output=`#{cmd}` + + result_code = $?.to_i + + if result_code == 0 + bpm = output.to_f + + @@log.debug("bpm: #{bpm} start_time: #{start_time}") + + metro_fin = "#{Time.at(start_time).utc.strftime("%H:%M:%S")}:#{((start_time - start_time.to_i) * 1000).round}" + + jmep = "" + jmep << "# created via code using bpm/silence detection (bpm:#{bpm})\r\n" + jmep << "prelude@10.0 #number of seconds before music starts\r\n" + jmep << "metro_fin@#{metro_fin} bpm=#{bpm}, ticks=8, pmode=stream, name=Beep, play=mono" + + @@log.info("jmep generated: #{jmep}") + + jam_track.jmep_text = jmep + if jam_track.save + finish('success', nil) + else + @@log.error("jamtrack did not save. #{jam_track.errors.inspect}") + finish("no-save", "jamtrack did not save. #{jam_track.errors.inspect}") + return + end + else + finish("bpm-fail", "failed to run bpm: #{output}") + return + end + end + end + end + + + + def determine_start_time(audio_file, tmp_dir, original_filename) + burp_gaps = ['0.3', '0.2', '0.1', '0.05'] + + out_wav = File.join(tmp_dir, 'stripped.wav') + total_time_command = "soxi -D \"#{audio_file}\"" + total_time = `#{total_time_command}`.to_f + + result_code = -20 + stripped_time = total_time # default to the case where we just start the preview at the beginning + + burp_gaps.each do |gap| + command_strip_lead_silence = "sox \"#{audio_file}\" \"#{out_wav}\" silence 1 #{gap} 1%" + + @@log.debug("stripping silence: " + command_strip_lead_silence) + + output = `#{command_strip_lead_silence}` + + result_code = $?.to_i + + if result_code == 0 + stripped_time_command = "soxi -D \"#{out_wav}\"" + stripped_time_test = `#{stripped_time_command}`.to_f + + if stripped_time_test < 1 # meaning a very short duration + @@log.warn("could not determine the start of non-silence. assuming beginning") + stripped_time = total_time # default to the case where we just start the preview at the beginning + else + stripped_time = stripped_time_test # accept the measured time of the stripped file and move on by using break + break + end + else + @@log.warn("unable to determine silence for jam_track #{original_filename}, #{output}") + stripped_time = total_time # default to the case where we just start the preview at the beginning + end + end + + preview_start_time = total_time - stripped_time + + preview_start_time + end def synchronize_preview_dev(jam_track) jam_track.jam_track_tracks.each do |track| @@ -231,6 +408,7 @@ module JamRuby original_artist = parsed_metalocation[1] name = parsed_metalocation[2] + JamTrackImporter.summaries[:unique_artists] << original_artist success = dry_run_metadata(metadata, original_artist, name) @@ -269,6 +447,11 @@ module JamRuby @storage_format == 'Tency' end + def is_tim_tracks_storage? + assert_storage_set + @storage_format == 'TimTracks' + end + def assert_storage_set raise "no storage_format set" if @storage_format.nil? end @@ -276,7 +459,7 @@ module JamRuby def parse_metalocation(metalocation) # metalocation = mapped/4 Non Blondes - What's Up - 6475/meta.yml - if is_tency_storage? + if is_tency_storage? || is_tim_tracks_storage? suffix = '/meta.yml' @@ -305,15 +488,21 @@ module JamRuby return nil end - last_dash = metalocation.rindex('-') - if last_dash - song = metalocation[(first_dash+3)...last_dash].strip + if is_tim_tracks_storage? + song = metalocation[(first_dash+3)..-1].strip bits << song - else - finish("invalid_metalocation", "metalocation not valid #{metalocation}") - return nil + elsif is_tency_storage? + last_dash = metalocation.rindex('-') + if last_dash + song = metalocation[(first_dash+3)...last_dash].strip + bits << song + else + finish("invalid_metalocation", "metalocation not valid #{metalocation}") + return nil + end end + bits << 'meta.yml' bits else @@ -338,24 +527,14 @@ module JamRuby end end - # if you change this, it will (at least without some work )break development usage of jamtracks - def gen_plan_code(original_artist, name) - # remove all non-alphanumeric chars from artist as well as name - artist_code = original_artist.gsub(/[^0-9a-z]/i, '').downcase - name_code = name.gsub(/[^0-9a-z]/i, '').downcase - "jamtrack-#{artist_code[0...20]}-#{name_code}"[0...50] # make sure it's a max of 50 long - end - def dry_run_metadata(metadata, original_artist, name) self.name = metadata["name"] || name original_artist = metadata["original_artist"] || original_artist - plan_code = metadata["plan_code"] || gen_plan_code(original_artist, self.name) description = metadata["description"] @@log.debug("#{self.name} original_artist=#{original_artist}") - @@log.debug("#{self.name} plan_code=#{plan_code}") true end @@ -494,7 +673,6 @@ module JamRuby jam_track.year = metadata[:year] jam_track.genres = determine_genres(metadata) jam_track.language = determine_language(metadata) - jam_track.plan_code = metadata["plan_code"] || gen_plan_code(jam_track.original_artist, jam_track.name) jam_track.price = 1.99 jam_track.reproduction_royalty_amount = nil jam_track.reproduction_royalty = true @@ -507,16 +685,25 @@ module JamRuby jam_track.alternative_license_status = false jam_track.hfa_license_desired = true jam_track.server_fixation_date = Time.now - jam_track.slug = metadata['slug'] - unless jam_track.slug - jam_track.generate_slug - end - if is_tency_storage? jam_track.vendor_id = metadata[:id] - jam_track.licensor = JamTrackLicensor.find_by_name('Tency Music') + jam_track.licensor = JamTrackLicensor.find_by_name!('Tency Music') #add_licensor_metadata('Tency Music', metalocation) + elsif is_tim_tracks_storage? + jam_track.vendor_id = metadata[:id] + jam_track.licensor = JamTrackLicensor.find_by_name!('Tim Waurick') end + jam_track.slug = metadata['slug'] + if jam_track.slug.nil? + jam_track.generate_slug + end + jam_track.plan_code = metadata["plan_code"] + if jam_track.plan_code.nil? + jam_track.gen_plan_code + end + + + else if !options[:resync_audio] #@@log.debug("#{self.name} skipped because it already exists in database") @@ -664,8 +851,11 @@ module JamRuby instrument = 'other' part = 'Bouzouki' elsif potential_instrument == 'claps' || potential_instrument == 'hand claps' - instrument = 'computer' + instrument = 'other' part = 'Claps' + elsif potential_instrument == 'snaps' || potential_instrument == 'snap' + instrument = 'other' + part = 'Snaps' else found_instrument = Instrument.find_by_id(potential_instrument) if found_instrument @@ -774,7 +964,6 @@ module JamRuby end end end - end @@ -900,6 +1089,10 @@ module JamRuby if track.track_type == 'Master' instrument_weight = 1000 end + + if track.track_type == 'Click' + instrument_weight = 10000 + end end @@ -976,7 +1169,22 @@ module JamRuby end - sorted_tracks[sorted_tracks.length - 1].position = 1000 + # get click/master tracks position re-set correctly + + last_track = sorted_tracks[sorted_tracks.length - 1] + second_to_last = sorted_tracks[sorted_tracks.length - 2] + + if last_track.track_type == 'Master' + last_track.position = 1000 + elsif last_track.track_type == 'Click' + last_track.position = 10000 + end + + if second_to_last.track_type == 'Master' + second_to_last.position = 1000 + elsif second_to_last.track_type == 'Click' + second_to_last.position = 10000 + end sorted_tracks end @@ -1082,7 +1290,6 @@ module JamRuby @@log.debug("#{self.name} track! instrument: #{parsed_wav[:instrument] ? parsed_wav[:instrument] : 'N/A'}, part: #{parsed_wav[:part] ? parsed_wav[:part] : 'N/A'}, filename: #{parsed_wav[:filename]} ") end - track.instrument_id = parsed_wav[:instrument] || 'other' track.track_type = 'Track' track.part = parsed_wav[:part] || "Other #{unknowns}" @@ -1093,6 +1300,13 @@ module JamRuby elsif parsed_wav[:type] == :clickwav file.file_type = 'ClickWav' addt_files << file + + # and also add a JamTrackTrack for this click track + track.track_type = 'Click' + track.part = 'Clicktrack' + track.instrument_id = 'computer' + track.position = 10000 + tracks << track elsif parsed_wav[:type] == :precount file.file_type = 'Precount' file.precount_num = parsed_wav[:precount_num] @@ -1142,97 +1356,8 @@ module JamRuby begin Dir.mktmpdir do |tmp_dir| - generate_mp3_aac_stem(jam_track, tmp_dir, skip_audio_upload) jam_track.jam_track_tracks.each do |track| - - basename = File.basename(track.original_audio_s3_path) - s3_dirname = File.dirname(track.original_audio_s3_path) - - # make a 44100 version, and a 48000 version - ogg_44100_filename = File.basename(basename, ".wav") + "-44100.ogg" - ogg_48000_filename = File.basename(basename, ".wav") + "-48000.ogg" - - ogg_44100_s3_path = track.filename(ogg_44100_filename) - ogg_48000_s3_path = track.filename(ogg_48000_filename) - - track.skip_uploader = true - - if skip_audio_upload - track["url_44"] = ogg_44100_s3_path - track["md5_44"] = 'md5' - track["length_44"] = 1 - - track["url_48"] = ogg_48000_s3_path - track["md5_48"] = 'md5' - track["length_48"] = 1 - - # we can't fake the preview as easily because we don't know the MD5 of the current item - #track["preview_md5"] = 'md5' - #track["preview_mp3_md5"] = 'md5' - #track["preview_url"] = track.preview_filename('md5', 'ogg') - #track["preview_length"] = 1 - #track["preview_mp3_url"] = track.preview_filename('md5', 'mp3') - #track["preview_mp3_length"] = 1 - #track["preview_start_time"] = 0 - else - wav_file = File.join(tmp_dir, basename) - - # bring the original wav file down from S3 to local file system - JamTrackImporter::song_storage_manager.download(track.original_audio_s3_path, wav_file) - - sample_rate = `soxi -r "#{wav_file}"`.strip - - ogg_44100 = File.join(tmp_dir, ogg_44100_filename) - ogg_48000 = File.join(tmp_dir, File.basename(basename, ".wav") + "-48000.ogg") - - if sample_rate == "44100" - `oggenc "#{wav_file}" -q 6 -o "#{ogg_44100}"` - else - `oggenc "#{wav_file}" --resample 44100 -q 6 -o "#{ogg_44100}"` - end - - if sample_rate == "48000" - `oggenc "#{wav_file}" -q 6 -o "#{ogg_48000}"` - else - `oggenc "#{wav_file}" --resample 48000 -q 6 -o "#{ogg_48000}"` - end - - # upload the new ogg files to s3 - @@log.debug("uploading 44100 to #{ogg_44100_s3_path}") - - jamkazam_s3_manager.upload(ogg_44100_s3_path, ogg_44100) - - @@log.debug("uploading 48000 to #{ogg_48000_s3_path}") - - jamkazam_s3_manager.upload(ogg_48000_s3_path, ogg_48000) - - ogg_44100_digest = ::Digest::MD5.file(ogg_44100) - # and finally update the JamTrackTrack with the new info - track["url_44"] = ogg_44100_s3_path - track["md5_44"] = ogg_44100_digest.hexdigest - track["length_44"] = File.new(ogg_44100).size - - track["url_48"] = ogg_48000_s3_path - track["md5_48"] = ::Digest::MD5.file(ogg_48000).hexdigest - track["length_48"] = File.new(ogg_48000).size - - synchronize_duration(jam_track, ogg_44100) - jam_track.save! - - # convert entire master ogg file to mp3, and push both to public destination - if track.track_type == 'Master' - preview_succeeded = synchronize_master_preview(track, tmp_dir, ogg_44100, ogg_44100_digest) - - if !preview_succeeded - return false - end - elsif track.track_type == 'Track' - synchronize_track_preview(track, tmp_dir, ogg_44100) - end - - end - - track.save! + synchronize_audio_track(jam_track, tmp_dir, skip_audio_upload, track) end end rescue Exception => e @@ -1243,6 +1368,139 @@ module JamRuby return true end + def synchronize_audio_track(jam_track, tmp_dir, skip_audio_upload, track) + basename = File.basename(track.original_audio_s3_path) + + # make a 44100 version, and a 48000 version + ogg_44100_filename = File.basename(basename, ".wav") + "-44100.ogg" + ogg_48000_filename = File.basename(basename, ".wav") + "-48000.ogg" + + + # make a 44100 version, and a 48000 version + mp3_48000_filename = File.basename(basename, ".wav") + "-48000.mp3" + aac_48000_filename = File.basename(basename, ".wav") + "-48000.aac" + + ogg_44100_s3_path = track.filename(ogg_44100_filename) + ogg_48000_s3_path = track.filename(ogg_48000_filename) + + mp3_48000_s3_path = track.filename(mp3_48000_filename) + aac_48000_s3_path = track.filename(aac_48000_filename) + + track.skip_uploader = true + + if skip_audio_upload + track["url_44"] = ogg_44100_s3_path + track["md5_44"] = 'md5' + track["length_44"] = 1 + + track["url_48"] = ogg_48000_s3_path + track["md5_48"] = 'md5' + track["length_48"] = 1 + + track["url_mp3_48"] = mp3_48000_filename + track["md5_mp3_48"] = 'md5' + track["length_mp3_48"] = 1 + + track["url_aac_48"] = aac_48000_filename + track["md5_aac_48"] = 'md5' + track["length_aac_48"] = 1 + + # we can't fake the preview as easily because we don't know the MD5 of the current item + #track["preview_md5"] = 'md5' + #track["preview_mp3_md5"] = 'md5' + #track["preview_url"] = track.preview_filename('md5', 'ogg') + #track["preview_length"] = 1 + #track["preview_mp3_url"] = track.preview_filename('md5', 'mp3') + #track["preview_mp3_length"] = 1 + #track["preview_start_time"] = 0 + else + wav_file = File.join(tmp_dir, basename) + + # bring the original wav file down from S3 to local file system + JamTrackImporter::song_storage_manager.download(track.original_audio_s3_path, wav_file) + + sample_rate = `soxi -r "#{wav_file}"`.strip + + ogg_44100 = File.join(tmp_dir, ogg_44100_filename) + ogg_48000 = File.join(tmp_dir, File.basename(basename, ".wav") + "-48000.ogg") + + if sample_rate == "44100" + `oggenc "#{wav_file}" -q 6 -o "#{ogg_44100}"` + else + `oggenc "#{wav_file}" --resample 44100 -q 6 -o "#{ogg_44100}"` + end + + if sample_rate == "48000" + `oggenc "#{wav_file}" -q 6 -o "#{ogg_48000}"` + else + `oggenc "#{wav_file}" --resample 48000 -q 6 -o "#{ogg_48000}"` + end + + # upload the new ogg files to s3 + @@log.debug("uploading 44100 to #{ogg_44100_s3_path}") + + jamkazam_s3_manager.upload(ogg_44100_s3_path, ogg_44100) + + @@log.debug("uploading 48000 to #{ogg_48000_s3_path}") + + jamkazam_s3_manager.upload(ogg_48000_s3_path, ogg_48000) + + ogg_44100_digest = ::Digest::MD5.file(ogg_44100) + # and finally update the JamTrackTrack with the new info + track["url_44"] = ogg_44100_s3_path + track["md5_44"] = ogg_44100_digest.hexdigest + track["length_44"] = File.new(ogg_44100).size + + track["url_48"] = ogg_48000_s3_path + track["md5_48"] = ::Digest::MD5.file(ogg_48000).hexdigest + track["length_48"] = File.new(ogg_48000).size + + # now create mp3 and aac files + mp3_48000 = File.join(tmp_dir, File.basename(basename, ".wav") + "-48000.mp3") + aac_48000 = File.join(tmp_dir, File.basename(basename, ".wav") + "-48000.aac") + + `ffmpeg -i "#{wav_file}" -ar 48000 -ab 192k "#{mp3_48000}"` + + `ffmpeg -i "#{wav_file}" -c:a libfdk_aac -b:a 192k "#{aac_48000}"` + + # upload the new ogg files to s3 + @@log.debug("uploading mp3 48000 to #{mp3_48000_s3_path}") + + jamkazam_s3_manager.upload(mp3_48000_s3_path, mp3_48000) + + @@log.debug("uploading aac 48000 to #{aac_48000_s3_path}") + + jamkazam_s3_manager.upload(aac_48000_s3_path, aac_48000) + + mp3_48000_digest = ::Digest::MD5.file(mp3_48000) + # and finally update the JamTrackTrack with the new info + track["url_mp3_48"] = mp3_48000_s3_path + track["md5_mp3_48"] = mp3_48000_digest.hexdigest + track["length_mp3_48"] = File.new(mp3_48000).size + + track["url_aac_48"] = aac_48000_s3_path + track["md5_aac_48"] = ::Digest::MD5.file(aac_48000).hexdigest + track["length_aac_48"] = File.new(aac_48000).size + + synchronize_duration(jam_track, ogg_44100) + jam_track.save! + + # convert entire master ogg file to mp3, and push both to public destination + if track.track_type == 'Master' + preview_succeeded = synchronize_master_preview(track, tmp_dir, ogg_44100, ogg_44100_digest) + + if !preview_succeeded + return false + end + elsif track.track_type == 'Track' || track.track_type == 'Click' + synchronize_track_preview(track, tmp_dir, ogg_44100) + end + + end + + track.save! + end + def generate_mp3_aac_stem(jam_track, tmp_dir, skip_audio_upload) jam_track.jam_track_tracks.each do |track| @@ -1252,6 +1510,7 @@ module JamRuby next end + puts "track.original_audio_s3_path #{track.original_audio_s3_path}" basename = File.basename(track.original_audio_s3_path) s3_dirname = File.dirname(track.original_audio_s3_path) @@ -1262,6 +1521,7 @@ module JamRuby mp3_48000_s3_path = track.filename(mp3_48000_filename) aac_48000_s3_path = track.filename(aac_48000_filename) + puts "mp3_48000_s3_path #{mp3_48000_s3_path}" track.skip_uploader = true if skip_audio_upload @@ -1341,58 +1601,15 @@ module JamRuby def synchronize_track_preview(track, tmp_dir, ogg_44100) - out_wav = File.join(tmp_dir, 'stripped.wav') - - burp_gaps = ['0.3', '0.2', '0.1', '0.05'] - - total_time_command = "soxi -D \"#{ogg_44100}\"" - total_time = `#{total_time_command}`.to_f - - result_code = -20 - stripped_time = total_time # default to the case where we just start the preview at the beginning - - burp_gaps.each do |gap| - command_strip_lead_silence = "sox \"#{ogg_44100}\" \"#{out_wav}\" silence 1 #{gap} 1%" - - @@log.debug("stripping silence: " + command_strip_lead_silence) - - output = `#{command_strip_lead_silence}` - - result_code = $?.to_i - - if result_code == 0 - stripped_time_command = "soxi -D \"#{out_wav}\"" - stripped_time_test = `#{stripped_time_command}`.to_f - - if stripped_time_test < 1 # meaning a very short duration - @@log.warn("could not determine the start of non-silencea. assuming beginning") - stripped_time = total_time # default to the case where we just start the preview at the beginning - else - stripped_time = stripped_time_test # accept the measured time of the stripped file and move on by using break - break - end - else - @@log.warn("unable to determine silence for jam_track #{track.original_filename}, #{output}") - stripped_time = total_time # default to the case where we just start the preview at the beginning - end - - end - - preview_start_time = total_time - stripped_time + preview_start_time = determine_start_time(ogg_44100, tmp_dir, track.original_filename) # this is in seconds; convert to integer milliseconds preview_start_time = (preview_start_time * 1000).to_i - preview_start_time = nil if preview_start_time < 0 + preview_start_time = 0 if preview_start_time < 0 track.preview_start_time = preview_start_time - if track.preview_start_time - @@log.debug("determined track start time to be #{track.preview_start_time}") - else - @@log.debug("determined track start time to be #{track.preview_start_time}") - end - track.process_preview(ogg_44100, tmp_dir) if track.preview_start_time if track.preview_generate_error @@ -1606,6 +1823,8 @@ module JamRuby def song_storage_manager if is_tency_storage? tency_s3_manager + elsif is_tim_tracks_storage? + tim_tracks_s3_manager else s3_manager end @@ -1619,6 +1838,10 @@ module JamRuby @tency_s3_manager ||= S3Manager.new('jamkazam-tency', APP_CONFIG.aws_access_key_id, APP_CONFIG.aws_secret_access_key) end + def tim_tracks_s3_manager + @tim_tracks_s3_manager ||= S3Manager.new('jamkazam-timtracks', APP_CONFIG.aws_access_key_id, APP_CONFIG.aws_secret_access_key) + end + def s3_manager @s3_manager ||= S3Manager.new(APP_CONFIG.aws_bucket_jamtracks, APP_CONFIG.aws_access_key_id, APP_CONFIG.aws_secret_access_key) end @@ -1657,10 +1880,32 @@ module JamRuby @storage_format == 'Tency' end + def is_tim_tracks_storage? + assert_storage_set + @storage_format == 'TimTracks' + end + def assert_storage_set raise "no storage_format set" if @storage_format.nil? end + def iterate_tim_tracks_song_storage(&blk) + count = 0 + song_storage_manager.list_directories('mapped').each do |song| + @@log.debug("searching through song directory '#{song}'") + + metalocation = "#{song}meta.yml" + + metadata = load_metalocation(metalocation) + + blk.call(metadata, metalocation) + + count += 1 + #break if count > 100 + + end + end + def iterate_tency_song_storage(&blk) count = 0 song_storage_manager.list_directories('mapped').each do |song| @@ -1700,6 +1945,10 @@ module JamRuby iterate_tency_song_storage do |metadata, metalocation| blk.call(metadata, metalocation) end + elsif is_tim_tracks_storage? + iterate_tim_tracks_song_storage do |metadata, metalocation| + blk.call(metadata, metalocation) + end else iterate_default_song_storage do |metadata, metalocation| blk.call(metadata, metalocation) @@ -1915,6 +2164,73 @@ module JamRuby end end + def import_click_track(jam_track) + importer = JamTrackImporter.new + importer.name = jam_track.name + importer.import_click_track(jam_track) + + importer + end + def generate_jmep(jam_track) + importer = JamTrackImporter.new + importer.name = jam_track.name + importer.generate_jmep(jam_track) + + importer + end + + def import_click_tracks + importers = [] + + JamTrack.all.each do |jam_track| + #jam_track = JamTrack.find('126') + importers << import_click_track(jam_track) + end + + @@log.info("SUMMARY") + @@log.info("-------") + importers.each do |importer| + if importer + if importer.reason == "success" + @@log.info("#{importer.name} #{importer.reason}") + else + @@log.error("#{importer.name} failed to generate jmep.") + @@log.error("#{importer.name} reason=#{importer.reason}") + @@log.error("#{importer.name} detail=#{importer.detail}") + end + else + @@log.error("NULL IMPORTER") + end + + end + end + + def generate_jmeps + importers = [] + + JamTrack.all.each do |jam_track| + importers << generate_jmep(jam_track) + end + + @@log.info("SUMMARY") + @@log.info("-------") + importers.each do |importer| + if importer + if importer.reason == "success" + @@log.info("#{importer.name} #{importer.reason}") + else + @@log.error("#{importer.name} failed to generate jmep.") + @@log.error("#{importer.name} reason=#{importer.reason}") + @@log.error("#{importer.name} detail=#{importer.detail}") + end + else + @@log.error("NULL IMPORTER") + end + + end + end + + def synchronize_previews importers = [] @@ -2328,7 +2644,12 @@ module JamRuby else begin data = s3_manager.read_all(metalocation) - return YAML.load(data) + meta = YAML.load(data) + + if is_tim_tracks_storage? + meta[:genres] = ['acapella'] + end + meta rescue AWS::S3::Errors::NoSuchKey return nil end @@ -2395,3 +2716,4 @@ module JamRuby end end end + diff --git a/ruby/lib/jam_ruby/jam_tracks_manager.rb b/ruby/lib/jam_ruby/jam_tracks_manager.rb index d6ae37b1e..96ccf87f8 100644 --- a/ruby/lib/jam_ruby/jam_tracks_manager.rb +++ b/ruby/lib/jam_ruby/jam_tracks_manager.rb @@ -41,7 +41,7 @@ module JamRuby jam_file_opts="" jam_track.jam_track_tracks.each do |jam_track_track| - next if jam_track_track.track_type != "Track" # master mixes do not go into the JKZ + next if jam_track_track.track_type == "Master" # master mixes do not go into the JKZ # use the jam_track_track ID as the filename.ogg/.wav, because it's important metadata nm = jam_track_track.id + File.extname(jam_track_track.url_by_sample_rate(sample_rate)) @@ -52,7 +52,8 @@ module JamRuby step = bump_step(jam_track_right, step) copy_url_to_file(track_url, track_filename) - jam_file_opts << " -i #{Shellwords.escape("#{track_filename}+#{jam_track_track.part}")}" + part = jam_track_track.track_type == 'Click' ? 'ClickTrack' : jam_track_track.part + jam_file_opts << " -i #{Shellwords.escape("#{track_filename}+#{part}")}" end #puts "LS + " + `ls -la '#{tmp_dir}'` diff --git a/ruby/lib/jam_ruby/models/affiliate_partner.rb b/ruby/lib/jam_ruby/models/affiliate_partner.rb index db41ddd12..e88aed9c7 100644 --- a/ruby/lib/jam_ruby/models/affiliate_partner.rb +++ b/ruby/lib/jam_ruby/models/affiliate_partner.rb @@ -119,18 +119,16 @@ class JamRuby::AffiliatePartner < ActiveRecord::Base end def should_attribute_sale?(shopping_cart) - if shopping_cart.is_jam_track? - if created_within_affiliate_window(shopping_cart.user, Time.now) - product_info = shopping_cart.product_info - # subtract the total quantity from the freebie quantity, to see how much we should attribute to them - real_quantity = product_info[:quantity].to_i - product_info[:marked_for_redeem].to_i - {fee_in_cents: (1.99 * 100 * real_quantity * rate.to_f).round} - else - false - end + + if created_within_affiliate_window(shopping_cart.user, Time.now) + product_info = shopping_cart.product_info + # subtract the total quantity from the freebie quantity, to see how much we should attribute to them + real_quantity = product_info[:quantity].to_i - product_info[:marked_for_redeem].to_i + {fee_in_cents: (product_info[:price] * 100 * real_quantity * rate.to_f).round} else - raise 'shopping cart type not implemented yet' + false end + end def cumulative_earnings_in_dollars diff --git a/ruby/lib/jam_ruby/models/anonymous_user.rb b/ruby/lib/jam_ruby/models/anonymous_user.rb index 24bc2b104..55c788e90 100644 --- a/ruby/lib/jam_ruby/models/anonymous_user.rb +++ b/ruby/lib/jam_ruby/models/anonymous_user.rb @@ -15,20 +15,47 @@ module JamRuby ShoppingCart.where(anonymous_user_id: @id).order('created_at DESC') end + def destroy_all_shopping_carts ShoppingCart.destroy_all(anonymous_user_id: @id) end + def destroy_jam_track_shopping_carts + ShoppingCart.destroy_all(anonymous_user_id: @id, cart_type: JamTrack::PRODUCT_TYPE) + end + def admin false end def has_redeemable_jamtrack + raise "not a cookied anonymous user" if @cookies.nil? + APP_CONFIG.one_free_jamtrack_per_user && !@cookies[:redeemed_jamtrack] end + def gifted_jamtracks + 0 + end + + def free_jamtracks + if has_redeemable_jamtrack + 1 + else + 0 + end + end + + def show_free_jamtrack? + ShoppingCart.user_has_redeemable_jam_track?(self) + end + def signup_hint SignupHint.where(anonymous_user_id: @id).where('expires_at > ?', Time.now).first end + + def reload + + end end end diff --git a/ruby/lib/jam_ruby/models/download_tracker.rb b/ruby/lib/jam_ruby/models/download_tracker.rb index f31001504..6a2bcf301 100644 --- a/ruby/lib/jam_ruby/models/download_tracker.rb +++ b/ruby/lib/jam_ruby/models/download_tracker.rb @@ -97,6 +97,7 @@ module JamRuby body = "IP Address: #{remote_ip}\n" body << "Download Count: #{violation['count']}\n" body << "Add to blacklist: #{IpBlacklist.admin_url}" + body << "Check Activity: #{IpBlacklist.admin_activity_url(remote_ip)}" AdminMailer.alerts({ subject:"Single IP Access Violation. IP:#{remote_ip}", diff --git a/ruby/lib/jam_ruby/models/gift_card.rb b/ruby/lib/jam_ruby/models/gift_card.rb new file mode 100644 index 000000000..0dc5f94e8 --- /dev/null +++ b/ruby/lib/jam_ruby/models/gift_card.rb @@ -0,0 +1,36 @@ +# represents the gift card you hold in your hand +module JamRuby + class GiftCard < ActiveRecord::Base + + @@log = Logging.logger[GiftCard] + + JAM_TRACKS_5 = 'jam_tracks_5' + JAM_TRACKS_10 = 'jam_tracks_10' + CARD_TYPES = + [ + JAM_TRACKS_5, + JAM_TRACKS_10 + ] + + + belongs_to :user, class_name: "JamRuby::User" + + validates :card_type, presence: true, inclusion: {in: CARD_TYPES} + validates :code, presence: true, uniqueness: true + + after_save :check_gifted + + def check_gifted + if user && user_id_changed? + if card_type == JAM_TRACKS_5 + user.gifted_jamtracks += 5 + elsif card_type == JAM_TRACKS_10 + user.gifted_jamtracks += 10 + else + raise "unknown card type #{card_type}" + end + user.save! + end + end + end +end diff --git a/ruby/lib/jam_ruby/models/gift_card_purchase.rb b/ruby/lib/jam_ruby/models/gift_card_purchase.rb new file mode 100644 index 000000000..0cfb00807 --- /dev/null +++ b/ruby/lib/jam_ruby/models/gift_card_purchase.rb @@ -0,0 +1,17 @@ +# reperesents the gift card you buy from the site (but physical gift card is modeled by GiftCard) +module JamRuby + class GiftCardPurchase < ActiveRecord::Base + + @@log = Logging.logger[GiftCardPurchase] + + attr_accessible :user, :gift_card_type + + def name + gift_card_type.sale_display + end + + # who purchased the card? + belongs_to :user, class_name: "JamRuby::User" + belongs_to :gift_card_type, class_name: "JamRuby::GiftCardType" + end +end diff --git a/ruby/lib/jam_ruby/models/gift_card_type.rb b/ruby/lib/jam_ruby/models/gift_card_type.rb new file mode 100644 index 000000000..8294dbfed --- /dev/null +++ b/ruby/lib/jam_ruby/models/gift_card_type.rb @@ -0,0 +1,70 @@ +# reperesents the gift card you buy from the site (but physical gift card is modeled by GiftCard) +module JamRuby + class GiftCardType < ActiveRecord::Base + + @@log = Logging.logger[GiftCardType] + + PRODUCT_TYPE = 'GiftCardType' + + JAM_TRACKS_5 = 'jam_tracks_5' + JAM_TRACKS_10 = 'jam_tracks_10' + CARD_TYPES = + [ + JAM_TRACKS_5, + JAM_TRACKS_10 + ] + + validates :card_type, presence: true, inclusion: {in: CARD_TYPES} + + def self.jam_track_5 + GiftCardType.find(JAM_TRACKS_5) + end + + def self.jam_track_10 + GiftCardType.find(JAM_TRACKS_10) + end + + def name + sale_display + end + + def price + if card_type == JAM_TRACKS_5 + 10.00 + elsif card_type == JAM_TRACKS_10 + 20.00 + else + raise "unknown card type #{card_type}" + end + end + + + def sale_display + if card_type == JAM_TRACKS_5 + 'JamTracks Gift Card (5)' + elsif card_type == JAM_TRACKS_10 + 'JamTracks Gift Card (10)' + else + raise "unknown card type #{card_type}" + end + end + + def plan_code + if card_type == JAM_TRACKS_5 + "jamtrack-giftcard-5" + elsif card_type == JAM_TRACKS_10 + "jamtrack-giftcard-10" + else + raise "unknown card type #{card_type}" + end + end + + def sales_region + 'Worldwide' + end + + def to_s + sale_display + end + end +end diff --git a/ruby/lib/jam_ruby/models/ip_blacklist.rb b/ruby/lib/jam_ruby/models/ip_blacklist.rb index e62020e26..a7099cba8 100644 --- a/ruby/lib/jam_ruby/models/ip_blacklist.rb +++ b/ruby/lib/jam_ruby/models/ip_blacklist.rb @@ -15,6 +15,10 @@ module JamRuby APP_CONFIG.admin_root_url + "/admin/ip_blacklists/" end + def self.admin_activity_url(remote_ip) + APP_CONFIG.admin_root_url + "/admin/download_trackers?q[remote_ip_equals]=#{URI.escape(remote_ip)}&commit=Filter&order=id_desc" + end + def admin_url APP_CONFIG.admin_root_url + "/admin/ip_blacklists/" + id end diff --git a/ruby/lib/jam_ruby/models/jam_track.rb b/ruby/lib/jam_ruby/models/jam_track.rb index bf200cfd7..4e3e63fe5 100644 --- a/ruby/lib/jam_ruby/models/jam_track.rb +++ b/ruby/lib/jam_ruby/models/jam_track.rb @@ -19,7 +19,7 @@ module JamRuby :reproduction_royalty, :public_performance_royalty, :reproduction_royalty_amount, :licensor_royalty_amount, :pro_royalty_amount, :plan_code, :initial_play_silence, :jam_track_tracks_attributes, :jam_track_tap_ins_attributes, :genre_ids, :version, :jmep_json, :jmep_text, :pro_ascap, :pro_bmi, :pro_sesac, :duration, - :server_fixation_date, :hfa_license_status, :hfa_license_desired, :alternative_license_status, :hfa_license_number, :hfa_song_code, :album_title, as: :admin + :server_fixation_date, :hfa_license_status, :hfa_license_desired, :alternative_license_status, :hfa_license_number, :hfa_song_code, :album_title, :year, as: :admin validates :name, presence: true, length: {maximum: 200} validates :plan_code, presence: true, uniqueness: true, length: {maximum: 50 } @@ -86,6 +86,10 @@ module JamRuby after_save :sync_reproduction_royalty after_save :sync_onboarding_exceptions + def increment_version! + self.version = version.to_i + 1 + save! + end def sync_reproduction_royalty @@ -155,6 +159,9 @@ module JamRuby true end + def sale_display + "JamTrack: " + name + end def duplicate_positions? counter = {} jam_track_tracks.each do |track| @@ -338,7 +345,7 @@ module JamRuby query = query.where('genre_id = ? ', options[:genre]) end - query = query.where("jam_track_tracks.instrument_id = '#{options[:instrument]}' and jam_track_tracks.track_type != 'Master'") unless options[:instrument].blank? + query = query.where("jam_track_tracks.instrument_id = '#{options[:instrument]}' and jam_track_tracks.track_type = 'Track'") unless options[:instrument].blank? query = query.where("jam_tracks.sales_region = '#{options[:availability]}'") unless options[:availability].blank? # FIXME: n+1 queries for rights and genres @@ -347,9 +354,8 @@ module JamRuby # :jam_track_rights, # :genres]) # { genres_jam_tracks: :genre }, - query = query.includes([{ jam_track_tracks: :instrument }, - { genres_jam_tracks: :genre }, - :jam_track_tap_ins]) + # query = query.includes([{ jam_track_tracks: :instrument }, + # { genres_jam_tracks: :genre }]) count = query.total_entries @@ -432,13 +438,20 @@ module JamRuby end end + def click_track_file + JamTrackFile.where(jam_track_id: self.id).where(file_type: 'ClickWav').first + end + + def click_track + JamTrackTrack.where(jam_track_id: self.id).where(track_type: 'Click').first + end def master_track JamTrackTrack.where(jam_track_id: self.id).where(track_type: 'Master').first end def stem_tracks - JamTrackTrack.where(jam_track_id: self.id).where(track_type: 'Track') + JamTrackTrack.where(jam_track_id: self.id).where("track_type = 'Track' or track_type = 'Click'") end def can_download?(user) @@ -465,6 +478,27 @@ module JamRuby def generate_slug self.slug = sluggarize(original_artist) + '-' + sluggarize(name) + + if licensor + raise "no slug on licensor #{licensor.id}" if licensor.slug.nil? + self.slug << "-" + licensor.slug + end + end + + def gen_plan_code + # remove all non-alphanumeric chars from artist as well as name + artist_code = original_artist.gsub(/[^0-9a-z]/i, '').downcase + name_code = name.gsub(/[^0-9a-z]/i, '').downcase + self.plan_code = "jamtrack-#{artist_code[0...20]}-#{name_code}" + + if licensor + raise "no slug on licensor #{licensor.id}" if licensor.slug.nil? + self.plan_code << "-" + licensor.slug + end + + self.plan_code = self.plan_code[0...50] # make sure it's a max of 50 long + + end def to_s @@ -492,5 +526,30 @@ module JamRuby Digest::MD5.hexdigest(dates) end + + attr_accessor :preview_generate_error + + before_save :jmep_json_generate + validate :jmep_text_validate + + def jmep_text_validate + begin + JmepManager.execute(self.jmep_text) + rescue ArgumentError => err + errors.add(:jmep_text, err.to_s) + end + end + + def jmep_json_generate + self.licensor_id = nil if self.licensor_id == '' + self.jmep_json = nil if self.jmep_json == '' + self.time_signature = nil if self.time_signature == '' + + begin + self[:jmep_json] = JmepManager.execute(self.jmep_text) + rescue ArgumentError => err + #errors.add(:jmep_text, err.to_s) + end + end end end diff --git a/ruby/lib/jam_ruby/models/jam_track_file.rb b/ruby/lib/jam_ruby/models/jam_track_file.rb index e7c880165..e31a95ba2 100644 --- a/ruby/lib/jam_ruby/models/jam_track_file.rb +++ b/ruby/lib/jam_ruby/models/jam_track_file.rb @@ -27,9 +27,18 @@ module JamRuby "jam_track_files" end + def licensor_suffix + suffix = '' + if jam_track.licensor + raise "no licensor name" if jam_track.licensor.name.nil? + suffix = " - #{jam_track.licensor.name}" + end + suffix + end + # create name of the file def filename(original_name) - "#{store_dir}/#{jam_track.original_artist}/#{jam_track.name}/#{original_name}" + "#{store_dir}/#{jam_track.original_artist}/#{jam_track.name}#{licensor_suffix}/#{original_name}" end def manually_uploaded_filename diff --git a/ruby/lib/jam_ruby/models/jam_track_licensor.rb b/ruby/lib/jam_ruby/models/jam_track_licensor.rb index e06e292bc..776418159 100644 --- a/ruby/lib/jam_ruby/models/jam_track_licensor.rb +++ b/ruby/lib/jam_ruby/models/jam_track_licensor.rb @@ -4,7 +4,7 @@ module JamRuby table_name = 'jam_track_licensors' attr_accessible :name, :description, :attention, :address_line_1, :address_line_2, - :city, :state, :zip_code, :contact, :email, :phone, as: :admin + :city, :state, :zip_code, :contact, :email, :phone, :slug, as: :admin validates :name, presence: true, uniqueness: true, length: {maximum: 200} validates :description, length: {maximum: 1000} diff --git a/ruby/lib/jam_ruby/models/jam_track_mixdown.rb b/ruby/lib/jam_ruby/models/jam_track_mixdown.rb index 3551dcdba..c1a30d073 100644 --- a/ruby/lib/jam_ruby/models/jam_track_mixdown.rb +++ b/ruby/lib/jam_ruby/models/jam_track_mixdown.rb @@ -83,6 +83,11 @@ module JamRuby end end + if parsed["count-in"] + all_quiet = false + tweaked = true + end + if all_quiet errors.add(:settings, 'are all muted') end diff --git a/ruby/lib/jam_ruby/models/jam_track_right.rb b/ruby/lib/jam_ruby/models/jam_track_right.rb index 808593322..63558f84a 100644 --- a/ruby/lib/jam_ruby/models/jam_track_right.rb +++ b/ruby/lib/jam_ruby/models/jam_track_right.rb @@ -14,6 +14,7 @@ module JamRuby belongs_to :last_mixdown, class_name: 'JamRuby::JamTrackMixdown', foreign_key: 'last_mixdown_id', inverse_of: :jam_track_right belongs_to :last_stem, class_name: 'JamRuby::JamTrackTrack', foreign_key: 'last_stem_id', inverse_of: :jam_track_right + validates :version, presence: true validates :user, presence: true validates :jam_track, presence: true validates :is_test_purchase, inclusion: {in: [true, false]} @@ -133,8 +134,33 @@ module JamRuby end end + def cleanup_old_package! + if self.jam_track.version != self.version + delete_s3_files + self[:url_48] = nil + self[:url_44] = nil + self.signing_queued_at = nil + self.signing_started_at_48 = nil + self.signing_started_at_44 = nil + self.last_signed_at = nil + self.current_packaging_step = nil + self.packaging_steps = nil + self.should_retry = false + self.signing_44 = false + self.signing_48 = false + self.signed_44 = false + self.signed_48 = false + self.queued = false + self.version = self.jam_track.version + self.save! + end + end # if the job is already signed, just queued up for signing, or currently signing, then don't enqueue... otherwise fire it off def enqueue_if_needed(sample_rate=48) + + # delete any package that's out dated + cleanup_old_package! + state = signing_state(sample_rate) if state == 'SIGNED' || state == 'SIGNING' || state == 'QUEUED' false @@ -148,9 +174,9 @@ module JamRuby # @return true if signed && file exists for the sample_rate specifed: def ready?(sample_rate=48) if sample_rate==48 - self.signed_48 && self.url_48.present? && self.url_48.file.exists? + self.signed_48 && self.url_48.present? && self.url_48.file.exists? && self.version == self.jam_track.version else - self.signed_44 && self.url_44.present? && self.url_44.file.exists? + self.signed_44 && self.url_44.present? && self.url_44.file.exists? && self.version == self.jam_track.version end end diff --git a/ruby/lib/jam_ruby/models/jam_track_search.rb b/ruby/lib/jam_ruby/models/jam_track_search.rb index 7a365ed60..4bbcde75b 100644 --- a/ruby/lib/jam_ruby/models/jam_track_search.rb +++ b/ruby/lib/jam_ruby/models/jam_track_search.rb @@ -75,7 +75,7 @@ module JamRuby sqlstr = "'#{instruments.join("','")}'" rel = rel.joins(:jam_track_tracks) rel = rel.where("jam_track_tracks.instrument_id IN (#{sqlstr})") - rel = rel.where("jam_track_tracks.track_type != 'Master'") + rel = rel.where("jam_track_tracks.track_type = 'Track'") end end diff --git a/ruby/lib/jam_ruby/models/jam_track_track.rb b/ruby/lib/jam_ruby/models/jam_track_track.rb index 22e8f17f3..989f62a66 100644 --- a/ruby/lib/jam_ruby/models/jam_track_track.rb +++ b/ruby/lib/jam_ruby/models/jam_track_track.rb @@ -6,7 +6,7 @@ module JamRuby include JamRuby::S3PublicManagerMixin # there should only be one Master per JamTrack, but there can be N Track per JamTrack - TRACK_TYPE = %w{Track Master} + TRACK_TYPE = %w{Track Master Click} @@log = Logging.logger[JamTrackTrack] @@ -41,9 +41,19 @@ module JamRuby "jam_track_tracks" end + + def licensor_suffix + suffix = '' + if jam_track.licensor + raise "no licensor name" if jam_track.licensor.name.nil? + suffix = " - #{jam_track.licensor.name}" + end + suffix + end + # create name of the file def filename(original_name) - "#{store_dir}/#{jam_track.original_artist}/#{jam_track.name}/#{original_name}" + "#{store_dir}/#{jam_track.original_artist}/#{jam_track.name}#{licensor_suffix}/#{original_name}" end # create name of the preview file. @@ -54,7 +64,7 @@ module JamRuby end def preview_directory - "jam_track_previews/#{jam_track.original_artist}/#{jam_track.name}" + "jam_track_previews/#{jam_track.original_artist}/#{jam_track.name}#{licensor_suffix}" end def has_preview? @@ -192,10 +202,10 @@ module JamRuby # input is the original ogg file for the track. tmp_dir is where this code can safely generate output stuff and have it cleaned up later def process_preview(input, tmp_dir) - raise "Does not include AAC generation. Must be updated before used." uuid = SecureRandom.uuid output = File.join(tmp_dir, "#{uuid}.ogg") output_mp3 = File.join(tmp_dir, "#{uuid}.mp3") + output_aac = File.join(tmp_dir, "#{uuid}.aac") start = self.preview_start_time.to_f / 1000 stop = start + 20 @@ -225,35 +235,55 @@ module JamRuby @@log.debug("fail #{result_code}") @preview_generate_error = "unable to execute mp3 convert command #{convert_output}" else - ogg_digest = ::Digest::MD5.file(output) - mp3_digest = ::Digest::MD5.file(output_mp3) - self["preview_md5"] = ogg_md5 = ogg_digest.hexdigest - self["preview_mp3_md5"] = mp3_md5 = mp3_digest.hexdigest - @@log.debug("uploading ogg preview to #{self.preview_filename('ogg')}") - s3_public_manager.upload(self.preview_filename(ogg_md5, 'ogg'), output, content_type: 'audio/ogg', content_md5: ogg_digest.base64digest) - @@log.debug("uploading mp3 preview to #{self.preview_filename('mp3')}") - s3_public_manager.upload(self.preview_filename(mp3_md5, 'mp3'), output_mp3, content_type: 'audio/mpeg', content_md5: mp3_digest.base64digest) + convert_aac_cmd = "#{APP_CONFIG.ffmpeg_path} -i \"#{output}\" -c:a libfdk_aac -b:a 192k \"#{output_aac}\"" + @@log.debug("converting to aac using: " + convert_aac_cmd) - self.skip_uploader = true + convert_output = `#{convert_aac_cmd}` - original_ogg_preview_url = self["preview_url"] - original_mp3_preview_url = self["preview_mp3_url"] + result_code = $?.to_i - # and finally update the JamTrackTrack with the new info - self["preview_url"] = self.preview_filename(ogg_md5, 'ogg') - self["preview_length"] = File.new(output).size - # and finally update the JamTrackTrack with the new info - self["preview_mp3_url"] = self.preview_filename(mp3_md5, 'mp3') - self["preview_mp3_length"] = File.new(output_mp3).size - self.save! + if result_code != 0 + @@log.debug("fail #{result_code}") + @preview_generate_error = "unable to execute aac convert command #{convert_output}" + else - # if all that worked, now delete old previews, if present - begin - s3_public_manager.delete(original_ogg_preview_url) if original_ogg_preview_url && original_ogg_preview_url != self["preview_url"] - s3_public_manager.delete(original_mp3_preview_url) if original_mp3_preview_url && original_mp3_preview_url != track["preview_mp3_url"] - rescue - puts "UNABLE TO CLEANUP OLD PREVIEW URL" + ogg_digest = ::Digest::MD5.file(output) + mp3_digest = ::Digest::MD5.file(output_mp3) + aac_digest = ::Digest::MD5.file(output_aac) + self["preview_md5"] = ogg_md5 = ogg_digest.hexdigest + self["preview_mp3_md5"] = mp3_md5 = mp3_digest.hexdigest + self["preview_aac_md5"] = aac_md5 = mp3_digest.hexdigest + + @@log.debug("uploading ogg preview to #{self.preview_filename('ogg')}") + s3_public_manager.upload(self.preview_filename(ogg_md5, 'ogg'), output, content_type: 'audio/ogg', content_md5: ogg_digest.base64digest) + @@log.debug("uploading mp3 preview to #{self.preview_filename('mp3')}") + s3_public_manager.upload(self.preview_filename(mp3_md5, 'mp3'), output_mp3, content_type: 'audio/mpeg', content_md5: mp3_digest.base64digest) + @@log.debug("uploading aac preview to #{self.preview_filename('aac')}") + s3_public_manager.upload(self.preview_filename(aac_md5, 'aac'), output_aac, content_type: 'audio/aac', content_md5: aac_digest.base64digest) + + self.skip_uploader = true + + original_ogg_preview_url = self["preview_url"] + original_mp3_preview_url = self["preview_mp3_url"] + original_aac_preview_url = self["preview_aac_url"] + + self["preview_url"] = self.preview_filename(ogg_md5, 'ogg') + self["preview_length"] = File.new(output).size + self["preview_mp3_url"] = self.preview_filename(mp3_md5, 'mp3') + self["preview_mp3_length"] = File.new(output_mp3).size + self["preview_aac_url"] = self.preview_filename(aac_md5, 'aac') + self["preview_aac_length"] = File.new(output_aac).size + self.save! + + # if all that worked, now delete old previews, if present + begin + s3_public_manager.delete(original_ogg_preview_url) if original_ogg_preview_url && original_ogg_preview_url != self["preview_url"] + s3_public_manager.delete(original_mp3_preview_url) if original_mp3_preview_url && original_mp3_preview_url != track["preview_mp3_url"] + s3_public_manager.delete(original_aac_preview_url) if original_aac_preview_url && original_aac_preview_url != track["preview_aac_url"] + rescue + puts "UNABLE TO CLEANUP OLD PREVIEW URL" + end end end diff --git a/ruby/lib/jam_ruby/models/recurly_transaction_web_hook.rb b/ruby/lib/jam_ruby/models/recurly_transaction_web_hook.rb index 9d0fc9bd4..006611f61 100644 --- a/ruby/lib/jam_ruby/models/recurly_transaction_web_hook.rb +++ b/ruby/lib/jam_ruby/models/recurly_transaction_web_hook.rb @@ -92,53 +92,15 @@ module JamRuby transaction.save! # now that we have the transaction saved, we also need to delete the jam_track_right if this is a refund, or voided - - if transaction.transaction_type == 'refund' || transaction.transaction_type == 'void' sale = Sale.find_by_recurly_invoice_id(transaction.invoice_id) - if sale && sale.is_jam_track_sale? - if sale.sale_line_items.length == 1 - if sale.recurly_total_in_cents == transaction.amount_in_cents - line_item = sale.sale_line_items[0] - jam_track = line_item.product - jam_track_right = jam_track.right_for_user(transaction.user) if jam_track - if jam_track_right - line_item.affiliate_refunded = true - line_item.affiliate_refunded_at = Time.now - line_item.save! + if sale + AdminMailer.recurly_alerts(transaction.user, { + subject: "ACTION REQUIRED: #{transaction.user.email} has refund on invoice", + body: "You will have to manually revoke any JamTrackRights in our database for the appropriate JamTracks" + }).deliver - jam_track_right.destroy - - # associate which JamTrack we assume this is related to in this one success case - transaction.jam_track = jam_track - transaction.save! - - AdminMailer.recurly_alerts(transaction.user, { - subject: "NOTICE: #{transaction.user.email} has had JamTrack: #{jam_track.name} revoked", - body: "A #{transaction.transaction_type} event came from Recurly for sale with Recurly invoice ID #{sale.recurly_invoice_id}. We deleted their right to the track in our own database as a result." - }).deliver - else - AdminMailer.recurly_alerts(transaction.user, { - subject: "NOTICE: #{transaction.user.email} got a refund, but unable to find JamTrackRight to delete", - body: "This should just mean the user already has no rights to the JamTrackRight when the refund came in. Not a big deal, but sort of weird..." - }).deliver - end - - else - AdminMailer.recurly_alerts(transaction.user, { - subject: "ACTION REQUIRED: #{transaction.user.email} got a refund it was not for total value of a JamTrack sale", - body: "We received a #{transaction.transaction_type} notice for an amount that was not the same as the original sale. So, no action was taken in the database. sale total: #{sale.recurly_total_in_cents}, refund amount: #{transaction.amount_in_cents}" - }).deliver - end - - - else - AdminMailer.recurly_alerts(transaction.user, { - subject: "ACTION REQUIRED: #{transaction.user.email} has refund on invoice with multiple JamTracks", - body: "You will have to manually revoke any JamTrackRights in our database for the appropriate JamTracks" - }).deliver - end else AdminMailer.recurly_alerts(transaction.user, { subject: "ACTION REQUIRED: #{transaction.user.email} has refund with no correlator to sales", diff --git a/ruby/lib/jam_ruby/models/sale.rb b/ruby/lib/jam_ruby/models/sale.rb index 70279f8eb..cddf6b8d8 100644 --- a/ruby/lib/jam_ruby/models/sale.rb +++ b/ruby/lib/jam_ruby/models/sale.rb @@ -69,27 +69,12 @@ module JamRuby } end - def self.preview_invoice(current_user, shopping_carts) - line_items = {jam_tracks: []} - shopping_carts_jam_tracks = [] - shopping_carts_subscriptions = [] - shopping_carts.each do |shopping_cart| - - if shopping_cart.is_jam_track? - shopping_carts_jam_tracks << shopping_cart - else - # XXX: this may have to be revisited when we actually have something other than JamTracks for puchase - shopping_carts_subscriptions << shopping_cart - end + def self.ios_purchase(current_user, jam_track, receipt) + jam_track_right = JamRuby::JamTrackRight.find_or_create_by_user_id_and_jam_track_id(current_user.id, jam_track.id) do |jam_track_right| + jam_track_right.redeemed = false + jam_track_right.version = jam_track.version end - - jam_track_items = preview_invoice_jam_tracks(current_user, shopping_carts_jam_tracks) - line_items[:jam_tracks] = jam_track_items if jam_track_items - - # TODO: process shopping_carts_subscriptions - - line_items end # place_order will create one or more sales based on the contents of shopping_carts for the current user @@ -99,19 +84,14 @@ module JamRuby def self.place_order(current_user, shopping_carts) sales = [] - shopping_carts_jam_tracks = [] - shopping_carts_subscriptions = [] - shopping_carts.each do |shopping_cart| - if shopping_cart.is_jam_track? - shopping_carts_jam_tracks << shopping_cart - else - # XXX: this may have to be revisited when we actually have something other than JamTracks for puchase - shopping_carts_subscriptions << shopping_cart - end + + if Sale.is_mixed(shopping_carts) + # the controller checks this too; this is just an extra-level of sanity checking + return sales end - jam_track_sale = order_jam_tracks(current_user, shopping_carts_jam_tracks) + jam_track_sale = order_jam_tracks(current_user, shopping_carts) sales << jam_track_sale if jam_track_sale # TODO: process shopping_carts_subscriptions @@ -119,22 +99,52 @@ module JamRuby sales end - def self.preview_invoice_jam_tracks(current_user, shopping_carts_jam_tracks) - ### XXX TODO; - # we currently use a fake plan in Recurly to estimate taxes using the Pricing.Attach metod in Recurly.js + def self.is_only_freebie(shopping_carts) + free = true + shopping_carts.each do |cart| + free = cart.product_info[:free] - # if we were to implement this the right way (ensure adjustments are on the account as necessary), then it would be better (more correct) - # just a pain to implement + if !free + break + end + end + free end - def self.is_only_freebie(shopping_carts_jam_tracks) - shopping_carts_jam_tracks.length == 1 && shopping_carts_jam_tracks[0].product_info[:free] + # we don't allow mixed shopping carts :/ + def self.is_mixed(shopping_carts) + free = false + non_free = false + shopping_carts.each do |cart| + if cart.product_info[:free] + free = true + else + non_free = true + end + end + free && non_free end # this method will either return a valid sale, or throw a RecurlyClientError or ActiveRecord validation error (save! failed) # it may return an nil sale if the JamTrack(s) specified by the shopping carts are already owned - def self.order_jam_tracks(current_user, shopping_carts_jam_tracks) + def self.order_jam_tracks(current_user, shopping_carts) + + shopping_carts_jam_tracks = [] + shopping_carts_subscriptions = [] + shopping_carts_gift_cards = [] + + shopping_carts.each do |shopping_cart| + if shopping_cart.is_jam_track? + shopping_carts_jam_tracks << shopping_cart + elsif shopping_cart.is_gift_card? + shopping_carts_gift_cards << shopping_cart + else + # XXX: this may have to be revisited when we actually have something other than JamTracks for puchase + raise "unknown shopping cart type #{shopping_cart.cart_type}" + shopping_carts_subscriptions << shopping_cart + end + end client = RecurlyClient.new @@ -143,8 +153,8 @@ module JamRuby sale = create_jam_track_sale(current_user) if sale.valid? - if is_only_freebie(shopping_carts_jam_tracks) - sale.process_jam_tracks(current_user, shopping_carts_jam_tracks, nil) + if is_only_freebie(shopping_carts) + sale.process_shopping_carts(current_user, shopping_carts, nil) sale.recurly_subtotal_in_cents = 0 sale.recurly_tax_in_cents = 0 @@ -159,11 +169,13 @@ module JamRuby return sale end - sale_line_item = sale.sale_line_items[0] - sale_line_item.recurly_tax_in_cents = 0 - sale_line_item.recurly_total_in_cents = 0 - sale_line_item.recurly_currency = 'USD' - sale_line_item.recurly_discount_in_cents = 0 + sale.sale_line_items.each do |sale_line_item| + sale_line_item = sale.sale_line_items[0] + sale_line_item.recurly_tax_in_cents = 0 + sale_line_item.recurly_total_in_cents = 0 + sale_line_item.recurly_currency = 'USD' + sale_line_item.recurly_discount_in_cents = 0 + end sale.save else @@ -173,7 +185,7 @@ module JamRuby purge_pending_adjustments(account) - created_adjustments = sale.process_jam_tracks(current_user, shopping_carts_jam_tracks, account) + created_adjustments = sale.process_shopping_carts(current_user, shopping_carts, account) # now invoice the sale ... almost done @@ -229,13 +241,13 @@ module JamRuby sale end - def process_jam_tracks(current_user, shopping_carts_jam_tracks, account) + def process_shopping_carts(current_user, shopping_carts, account) created_adjustments = [] begin - shopping_carts_jam_tracks.each do |shopping_cart| - process_jam_track(current_user, shopping_cart, account, created_adjustments) + shopping_carts.each do |shopping_cart| + process_shopping_cart(current_user, shopping_cart, account, created_adjustments) end rescue Recurly::Error, NoMethodError => x # rollback any adjustments created if error @@ -251,7 +263,7 @@ module JamRuby end - def process_jam_track(current_user, shopping_cart, account, created_adjustments) + def process_shopping_cart(current_user, shopping_cart, account, created_adjustments) recurly_adjustment_uuid = nil recurly_adjustment_credit_uuid = nil @@ -259,15 +271,20 @@ module JamRuby shopping_cart.reload # get the JamTrack in this shopping cart - jam_track = shopping_cart.cart_product + cart_product = shopping_cart.cart_product - if jam_track.right_for_user(current_user) - # if the user already owns the JamTrack, we should just skip this cart item, and destroy it - # if this occurs, we have to reload every shopping_cart as we iterate. so, we do at the top of the loop - ShoppingCart.remove_jam_track_from_cart(current_user, shopping_cart) - return + if shopping_cart.is_jam_track? + jam_track = cart_product + if jam_track.right_for_user(current_user) + # if the user already owns the JamTrack, we should just skip this cart item, and destroy it + # if this occurs, we have to reload every shopping_cart as we iterate. so, we do at the top of the loop + ShoppingCart.remove_jam_track_from_cart(current_user, shopping_cart) + return + end end + + if account # ask the shopping cart to create the correct Recurly adjustment attributes for a JamTrack adjustments = shopping_cart.create_adjustment_attributes(current_user) @@ -300,38 +317,70 @@ module JamRuby # if the sale line item is invalid, blow up the transaction unless sale_line_item.valid? - @log.error("sale item invalid! #{sale_line_item.errors.inspect}") + @@log.error("sale item invalid! #{sale_line_item.errors.inspect}") puts("sale item invalid! #{sale_line_item.errors.inspect}") Stats.write('web.recurly.purchase.sale_invalid', {message: sale_line_item.errors.to_s, value: 1}) raise RecurlyClientError.new(sale_line_item.errors) end - # create a JamTrackRight (this needs to be in a transaction too to make sure we don't make these by accident) - jam_track_right = JamRuby::JamTrackRight.find_or_create_by_user_id_and_jam_track_id(current_user.id, jam_track.id) do |jam_track_right| - jam_track_right.redeemed = shopping_cart.free? - end + if shopping_cart.is_jam_track? + jam_track = cart_product - # also if the purchase was a free one, then update the user record to no longer allow redeemed jamtracks - if shopping_cart.free? - User.where(id: current_user.id).update_all(has_redeemable_jamtrack: false) - current_user.has_redeemable_jamtrack = false # make sure model reflects the truth - end - - - # this can't go in the block above, as it's here to fix bad subscription UUIDs in an update path - if jam_track_right.recurly_adjustment_uuid != recurly_adjustment_uuid - jam_track_right.recurly_adjustment_uuid = recurly_adjustment_uuid - jam_track_right.recurly_adjustment_credit_uuid = recurly_adjustment_credit_uuid - unless jam_track_right.save - raise RecurlyClientError.new(jam_track_right.errors) + # create a JamTrackRight (this needs to be in a transaction too to make sure we don't make these by accident) + jam_track_right = JamRuby::JamTrackRight.find_or_create_by_user_id_and_jam_track_id(current_user.id, jam_track.id) do |jam_track_right| + jam_track_right.redeemed = shopping_cart.free? + jam_track_right.version = jam_track.version end + + # also if the purchase was a free one, then: + # first, mark the free has_redeemable_jamtrack field if that's still true + # and if still they have more free things, then redeem the giftable_jamtracks + if shopping_cart.free? + if user.has_redeemable_jamtrack + User.where(id: current_user.id).update_all(has_redeemable_jamtrack: false) + current_user.has_redeemable_jamtrack = false + else + User.where(id: current_user.id).update_all(gifted_jamtracks: current_user.gifted_jamtracks - 1) + current_user.gifted_jamtracks = current_user.gifted_jamtracks - 1 + end + end + + + # this can't go in the block above, as it's here to fix bad subscription UUIDs in an update path + if jam_track_right.recurly_adjustment_uuid != recurly_adjustment_uuid + jam_track_right.recurly_adjustment_uuid = recurly_adjustment_uuid + jam_track_right.recurly_adjustment_credit_uuid = recurly_adjustment_credit_uuid + unless jam_track_right.save + raise RecurlyClientError.new(jam_track_right.errors) + end + end + + # blow up the transaction if the JamTrackRight did not get created + raise RecurlyClientError.new(jam_track_right.errors) if jam_track_right.errors.any? + + elsif shopping_cart.is_gift_card? + gift_card_type = cart_product + raise "gift card is null" if gift_card_type.nil? + raise if current_user.nil? + + shopping_cart.quantity.times do |item| + gift_card_purchase = GiftCardPurchase.new( + { + user: current_user, + gift_card_type: gift_card_type + }) + + unless gift_card_purchase.save + raise RecurlyClientError.new(gift_card_purchase.errors) + end + end + + else + raise 'unknown shopping cart type: ' + shopping_cart.cart_type end # delete the shopping cart; it's been dealt with shopping_cart.destroy if shopping_cart - - # blow up the transaction if the JamTrackRight did not get created - raise RecurlyClientError.new(jam_track_right.errors) if jam_track_right.errors.any? end @@ -361,7 +410,7 @@ module JamRuby def self.create_jam_track_sale(user) sale = Sale.new sale.user = user - sale.sale_type = JAMTRACK_SALE + sale.sale_type = JAMTRACK_SALE # gift cards and jam tracks are sold with this type of sale sale.order_total = 0 sale.save sale diff --git a/ruby/lib/jam_ruby/models/sale_line_item.rb b/ruby/lib/jam_ruby/models/sale_line_item.rb index 7d744cfe5..5cbe5ad87 100644 --- a/ruby/lib/jam_ruby/models/sale_line_item.rb +++ b/ruby/lib/jam_ruby/models/sale_line_item.rb @@ -4,14 +4,16 @@ module JamRuby JAMBLASTER = 'JamBlaster' JAMCLOUD = 'JamCloud' JAMTRACK = 'JamTrack' + GIFTCARD = 'GiftCardType' belongs_to :sale, class_name: 'JamRuby::Sale' belongs_to :jam_track, class_name: 'JamRuby::JamTrack' belongs_to :jam_track_right, class_name: 'JamRuby::JamTrackRight' + belongs_to :gift_card, class_name: 'JamRuby::GiftCard' belongs_to :affiliate_referral, class_name: 'JamRuby::AffiliatePartner', foreign_key: :affiliate_referral_id has_many :recurly_transactions, class_name: 'JamRuby::RecurlyTransactionWebHook', inverse_of: :sale_line_item, foreign_key: 'subscription_id', primary_key: 'recurly_subscription_uuid' - validates :product_type, inclusion: {in: [JAMBLASTER, JAMCLOUD, JAMTRACK]} + validates :product_type, inclusion: {in: [JAMBLASTER, JAMCLOUD, JAMTRACK, GIFTCARD]} validates :unit_price, numericality: {only_integer: false} validates :quantity, numericality: {only_integer: true} validates :free, numericality: {only_integer: true} @@ -21,9 +23,19 @@ module JamRuby validates :recurly_plan_code, presence:true validates :sale, presence:true + def is_jam_track? + product_type == JAMTRACK + end + + def is_gift_card? + product_type == GIFTCARD + end + def product if product_type == JAMTRACK JamTrack.find_by_id(product_id) + elsif product_type == GIFTCARD + GiftCardType.find_by_id(product_id) else raise 'unsupported product type' end diff --git a/ruby/lib/jam_ruby/models/shopping_cart.rb b/ruby/lib/jam_ruby/models/shopping_cart.rb index 568d94048..fb531c2bd 100644 --- a/ruby/lib/jam_ruby/models/shopping_cart.rb +++ b/ruby/lib/jam_ruby/models/shopping_cart.rb @@ -12,6 +12,8 @@ module JamRuby attr_accessible :quantity, :cart_type, :product_info + attr_accessor :skip_mix_check + validates_uniqueness_of :cart_id, scope: [:cart_type, :user_id, :anonymous_user_id] belongs_to :user, :inverse_of => :shopping_carts, :class_name => "JamRuby::User", :foreign_key => "user_id" @@ -20,12 +22,13 @@ module JamRuby validates :cart_type, presence: true validates :cart_class_name, presence: true validates :marked_for_redeem, numericality: {only_integer: true} + validate :not_mixed default_scope order('created_at DESC') def product_info product = self.cart_product - {name: product.name, price: product.price, product_id: cart_id, plan_code: product.plan_code, real_price: real_price(product), total_price: total_price(product), quantity: quantity, marked_for_redeem: marked_for_redeem, free: free?, sales_region: product.sales_region} unless product.nil? + {type: cart_type, name: product.name, price: product.price, product_id: cart_id, plan_code: product.plan_code, real_price: real_price(product), total_price: total_price(product), quantity: quantity, marked_for_redeem: marked_for_redeem, free: free?, sales_region: product.sales_region, sale_display:product.sale_display} unless product.nil? end # multiply quantity by price @@ -38,6 +41,31 @@ module JamRuby (quantity - marked_for_redeem) * product.price end + def not_mixed + + return if @skip_mix_check + existing_carts = [] + this_user = any_user() + + if this_user + existing_carts = this_user.shopping_carts + end + + existing_carts = existing_carts.to_a + existing_carts << self + + if Sale.is_mixed(existing_carts) + if free? + errors.add(:base, "You can not add a free JamTrack to a cart with non-free items. Please clear out your cart.") + return false + else + errors.add(:base, "You can not add a non-free JamTrack to a cart containing free items. Please clear out your cart.") + return false + end + end + + false + end def cart_product self.cart_class_name.classify.constantize.find_by_id(self.cart_id) unless self.cart_class_name.blank? @@ -51,7 +79,18 @@ module JamRuby marked_for_redeem == quantity end + def any_user + if user + user + elsif anonymous_user_id + AnonymousUser.new(anonymous_user_id, nil) + else + nil + end + end + def self.create user, product, quantity = 1, mark_redeem = false + cart = ShoppingCart.new if user.is_a?(User) cart.user = user @@ -72,39 +111,42 @@ module JamRuby cart_type == JamTrack::PRODUCT_TYPE end + def is_gift_card? + cart_type == GiftCardType::PRODUCT_TYPE + end # returns an array of adjustments for the shopping cart def create_adjustment_attributes(current_user) - raise "not a jam track" unless is_jam_track? + raise "not a jam track or gift card" unless is_jam_track? || is_gift_card? info = self.product_info if free? - # create the credit, then the pseudo charge [ { accounting_code: PURCHASE_FREE_CREDIT, currency: 'USD', unit_amount_in_cents: -(info[:total_price] * 100).to_i, - description: "JamTrack: " + info[:name] + " (Credit)", + description: info[:sale_display] + " (Credit)", tax_exempt: true }, { accounting_code: PURCHASE_FREE, currency: 'USD', unit_amount_in_cents: (info[:total_price] * 100).to_i, - description: "JamTrack: " + info[:name], + description: info[:sale_display], tax_exempt: true } ] else + [ { accounting_code: PURCHASE_NORMAL, currency: 'USD', unit_amount_in_cents: (info[:total_price] * 100).to_i, - description: "JamTrack: " + info[:name], + description: info[:sale_display], tax_exempt: false } ] @@ -113,8 +155,13 @@ module JamRuby def self.move_to_user(user, anonymous_user, shopping_carts) shopping_carts.each do |shopping_cart| - mark_redeem = ShoppingCart.user_has_redeemable_jam_track?(user) - cart = ShoppingCart.create(user, shopping_cart.cart_product, shopping_cart.quantity, mark_redeem) + if shopping_cart.is_jam_track? + mark_redeem = ShoppingCart.user_has_redeemable_jam_track?(user) + cart = ShoppingCart.create(user, shopping_cart.cart_product, shopping_cart.quantity, mark_redeem) + else + cart = ShoppingCart.create(user, shopping_cart.cart_product, shopping_cart.quantity, false) + end + end anonymous_user.destroy_all_shopping_carts @@ -134,28 +181,32 @@ module JamRuby # if no shpping carts have been marked, then mark it redeemable # should be wrapped in a TRANSACTION def self.user_has_redeemable_jam_track?(any_user) - mark_redeem = false - if APP_CONFIG.one_free_jamtrack_per_user && any_user.has_redeemable_jamtrack - mark_redeem = true # start out assuming we can redeem... + + if any_user.has_redeemable_jamtrack || any_user.gifted_jamtracks > 0 + + free_in_cart = 0 any_user.shopping_carts.each do |shopping_cart| # but if we find any shopping cart item already marked for redeem, then back out of mark_redeem=true - if shopping_cart.cart_type == JamTrack::PRODUCT_TYPE && shopping_cart.marked_for_redeem > 0 - mark_redeem = false - break + if shopping_cart.cart_type == JamTrack::PRODUCT_TYPE + free_in_cart += shopping_cart.marked_for_redeem end end + + any_user.free_jamtracks > free_in_cart + else + false end - mark_redeem end # adds a jam_track to cart, checking for promotions - def self.add_jam_track_to_cart(any_user, jam_track) + def self.add_jam_track_to_cart(any_user, jam_track, clear:false) cart = nil ShoppingCart.transaction do - if any_user.has_redeemable_jamtrack - # if you still have a freebie available to you, or if you are an anonymous user, we make sure there is nothing else in your shopping cart - any_user.destroy_all_shopping_carts + if clear + # if you are an anonymous user, we make sure there is nothing else in your shopping cart ... keep it clean for the 'new user rummaging around for a freebie scenario' + any_user.destroy_jam_track_shopping_carts + any_user.reload end mark_redeem = ShoppingCart.user_has_redeemable_jam_track?(any_user) @@ -164,23 +215,66 @@ module JamRuby cart end + def self.add_item_to_cart(any_user, item) + cart = nil + ShoppingCart.transaction do + cart = ShoppingCart.create(any_user, item, 1, false) + end + cart + end + # deletes a jam track from the shopping cart, updating redeem flag as necessary def self.remove_jam_track_from_cart(any_user, cart) ShoppingCart.transaction do cart.destroy - # check if we should move the redemption + + # so that user.shopping_carts reflects truth + any_user.reload + + # check if we should move the redemption around automatically mark_redeem = ShoppingCart.user_has_redeemable_jam_track?(any_user) carts = any_user.shopping_carts - # if we find any carts on the account, mark one redeemable + # if we find any carts on the account that are not redeemed, mark first one redeemable if mark_redeem && carts.length > 0 - carts[0].redeem(mark_redeem) - carts[0].save + carts.each do |cart| + if cart.marked_for_redeem == 0 + if cart.quantity > 1 + raise 'unknown situation for redeemption juggling' + end + cart.redeem(mark_redeem) + cart.save + break + end + end end end end + def self.remove_item_from_cart(any_user, cart) + ShoppingCart.transaction do + cart.destroy + end + end + + # if the number of items in the shopping cart is less than gifted_jamtracks on the user, then fix them all up + def self.apply_gifted_jamtracks(user) + jam_track_carts = user.shopping_carts.where(cart_type:JamTrack::PRODUCT_TYPE) + + if jam_track_carts.count > user.gifted_jamtracks + # just whack everything in their shopping cart + user.destroy_all_shopping_carts + return + end + + jam_track_carts.each do |cart| + cart.skip_mix_check = true + cart.marked_for_redeem = 1 + cart.save! + end + end + def port(user, anonymous_user) ShoppingCart.transaction do diff --git a/ruby/lib/jam_ruby/models/user.rb b/ruby/lib/jam_ruby/models/user.rb index a9c46801a..907cd9776 100644 --- a/ruby/lib/jam_ruby/models/user.rb +++ b/ruby/lib/jam_ruby/models/user.rb @@ -40,7 +40,7 @@ module JamRuby attr_accessible :first_name, :last_name, :email, :city, :password, :password_confirmation, :state, :country, :birth_date, :subscribe_email, :terms_of_service, :original_fpfile, :cropped_fpfile, :cropped_large_fpfile, :cropped_s3_path, :cropped_large_s3_path, :photo_url, :large_photo_url, :crop_selection # updating_password corresponds to a lost_password - attr_accessor :updating_password, :updating_email, :updated_email, :update_email_confirmation_url, :administratively_created, :current_password, :setting_password, :confirm_current_password, :updating_avatar, :updating_progression_field, :mods_json + attr_accessor :updating_password, :updating_email, :updated_email, :update_email_confirmation_url, :administratively_created, :current_password, :setting_password, :confirm_current_password, :updating_avatar, :updating_progression_field, :mods_json, :expecting_gift_card belongs_to :icecast_server_group, class_name: "JamRuby::IcecastServerGroup", inverse_of: :users, foreign_key: 'icecast_server_group_id' @@ -148,6 +148,11 @@ module JamRuby # events has_many :event_sessions, :class_name => "JamRuby::EventSession" + # gift cards + has_many :gift_cards, :class_name=> "JamRuby::GiftCard" + has_many :gift_card_purchases, :class_name=> "JamRuby::GiftCardPurchase" + + # affiliate_partner has_one :affiliate_partner, :class_name => "JamRuby::AffiliatePartner", :foreign_key => :partner_user_id, inverse_of: :partner_user belongs_to :affiliate_referral, :class_name => "JamRuby::AffiliatePartner", :foreign_key => :affiliate_referral_id, :counter_cache => :referral_user_count @@ -194,6 +199,7 @@ module JamRuby validates :terms_of_service, :acceptance => {:accept => true, :on => :create, :allow_nil => false } validates :reuse_card, :inclusion => {:in => [true, false]} validates :has_redeemable_jamtrack, :inclusion => {:in => [true, false]} + validates :gifted_jamtracks, presence: true, :numericality => { :less_than_or_equal_to => 100 } validates :subscribe_email, :inclusion => {:in => [nil, true, false]} validates :musician, :inclusion => {:in => [true, false]} validates :show_whats_next, :inclusion => {:in => [nil, true, false]} @@ -214,6 +220,7 @@ module JamRuby validate :email_case_insensitive_uniqueness validate :update_email_case_insensitive_uniqueness, :if => :updating_email validate :validate_mods + validate :presence_gift_card, :if => :expecting_gift_card scope :musicians, where(:musician => true) scope :fans, where(:musician => false) @@ -233,6 +240,18 @@ module JamRuby end end + def has_any_free_jamtracks + has_redeemable_jamtrack || gifted_jamtracks > 0 + end + + def free_jamtracks + (has_redeemable_jamtrack ? 1 : 0) + gifted_jamtracks + end + + def show_free_jamtrack? + ShoppingCart.user_has_redeemable_jam_track?(self) + end + def failed_qualification(reason) self.last_failed_certified_gear_at = DateTime.now self.last_failed_certified_gear_reason = reason @@ -255,6 +274,12 @@ module JamRuby end end + def presence_gift_card + if self.gift_cards.length == 0 + errors.add(:gift_card, ValidationMessages::NOT_FOUND) + end + end + def validate_current_password # checks if the user put in their current password (used when changing your email, for instance) errors.add(:current_password, ValidationMessages::NOT_YOUR_PASSWORD) if should_confirm_existing_password? && !valid_password?(self.current_password) @@ -1025,6 +1050,7 @@ module JamRuby reuse_card = options[:reuse_card] signup_hint = options[:signup_hint] affiliate_partner = options[:affiliate_partner] + gift_card = options[:gift_card] user = User.new @@ -1036,6 +1062,9 @@ module JamRuby user.terms_of_service = terms_of_service user.musician = musician user.reuse_card unless reuse_card.nil? + user.gifted_jamtracks = 0 + user.has_redeemable_jamtrack = true + # FIXME: Setting random password for social network logins. This # is because we have validations all over the place on this. @@ -1140,8 +1169,22 @@ module JamRuby end end + found_gift_card = nil + + # if a gift card value was passed in, then try to find that gift card and apply it to user + if gift_card + user.expecting_gift_card = true + found_gift_card = GiftCard.where(code:gift_card).where(user_id:nil).first + user.gift_cards << found_gift_card if found_gift_card + end + user.save + if found_gift_card + user.reload + ShoppingCart.apply_gifted_jamtracks(user) + end + # if the user has just one, free jamtrack in their shopping cart, and it matches the signup hint, then auto-buy it # only_freebie_in_cart = # signup_hint && @@ -1181,6 +1224,7 @@ module JamRuby end end end + user.reload if user.id# gift card adding gifted_jamtracks doesn't reflect here until reload user end # def signup @@ -1636,6 +1680,11 @@ module JamRuby ShoppingCart.where("user_id=?", self).destroy_all end + def destroy_jam_track_shopping_carts + ShoppingCart.destroy_all(anonymous_user_id: @id, cart_type: JamTrack::PRODUCT_TYPE) + end + + def unsubscribe_token self.class.create_access_token(self) end diff --git a/ruby/lib/jam_ruby/resque/jam_track_mixdown_packager.rb b/ruby/lib/jam_ruby/resque/jam_track_mixdown_packager.rb index c954e62d3..191e41d33 100644 --- a/ruby/lib/jam_ruby/resque/jam_track_mixdown_packager.rb +++ b/ruby/lib/jam_ruby/resque/jam_track_mixdown_packager.rb @@ -10,9 +10,11 @@ module JamRuby include JamRuby::S3ManagerMixin + TAP_IN_PADDING = 2 MAX_PAN = 90 MIN_PAN = -90 + KNOCK_SECONDS = 0.035 attr_accessor :mixdown_package_id, :settings, :mixdown_package, :mixdown, :step @queue = :jam_track_mixdown_packager @@ -55,6 +57,8 @@ module JamRuby @mixdown = @mixdown_package.jam_track_mixdown @settings = JSON.parse(@mixdown.settings) + process_jmep + track_settings # compute the step count @@ -102,6 +106,236 @@ module JamRuby vol != 1.0 || pan != 0 end + def process_jmep + @start_points = [] + @initial_padding = 0.0 + + speed = @settings['speed'] || 0 + + @speed_factor = 1.0 + (-speed.to_f / 100.0) + @inverse_speed_factor = 1 - (-speed.to_f / 100) + + log.info("speed factor #{@speed_factor}") + + jmep = @mixdown.jam_track.jmep_json + if jmep + jmep = JSON.parse(jmep) + end + + if jmep.nil? + log.debug("no jmep") + return + end + + events = jmep["Events"] + + return if events.nil? || events.length == 0 + + metronome = nil + events.each do |event| + if event.has_key?("metronome") + metronome = event["metronome"] + break + end + end + + if metronome.nil? || metronome.length == 0 + log.debug("no metronome events for jmep", jmep) + return + end + + @start_points = metronome.select { |x| puts x.inspect; x["action"] == "start" } + + log.debug("found #{@start_points.length} metronome start points") + + start_point = @start_points[0] + + if start_point + start_time = parse_time(start_point["ts"]) + + if start_time < 2.0 + padding = start_time - 2.0 + @initial_padding = padding.abs + @initial_tap_in = start_time + end + end + + if @speed_factor != 1.0 + metronome.length.times do |count| + + # we expect to find metronome start/stop grouped + if count % 2 == 0 + + start = metronome[count] + stop = metronome[count + 1] + + if start["action"] != "start" || stop["action"] != "stop" + # bail out + log.error("found de-coupled metronome events #{start.to_json} | #{stop.to_json}") + next + end + + bpm = start["bpm"].to_f + stop_time = parse_time(stop['ts']) + ticks = stop['ticks'].to_i + + + new_bpm = bpm * @inverse_speed_factor + new_stop_time = stop_time * @speed_factor + new_start_time = new_stop_time - (60.0/new_bpm * ticks) + + log.info("original bpm:#{bpm} start: #{parse_time(start["ts"])} stop: #{stop_time}") + log.info("updated bpm:#{new_bpm} start: #{new_start_time} stop: #{new_stop_time}") + + stop["ts"] = new_stop_time + start["ts"] = new_start_time + start["bpm"] = new_bpm + stop["bpm"] = new_bpm + + @tap_in_initial_silence = (@initial_tap_in + @initial_padding) * @speed_factor + + end + + end + end + + @start_points = metronome.select { |x| puts x.inspect; x["action"] == "start" } + + end + + # format like: "-0:00:02:820" + def parse_time(ts) + + if ts.is_a?(Float) + return ts + end + + time = 0.0 + negative = false + + if ts.start_with?('-') + negative = true + end + + # parse time_format + bits = ts.split(':').reverse + + bit_position = 0 + bits.each do |bit| + if bit_position == 0 + # milliseconds + milliseconds = bit.to_f + time += milliseconds/1000 + elsif bit_position == 1 + # seconds + time += bit.to_f + elsif bit_position == 2 + # minutes + time += 60 * bit.to_f + elsif bit_position == 3 + # hours + # not bothering + end + + bit_position += 1 + end + + if negative + time = 0.0 - time + end + + time + end + + def path_to_resources + File.join(File.dirname(File.expand_path(__FILE__)), '../../../lib/jam_ruby/app/assets/sounds') + end + + def knock_file + if long_sample_rate == 44100 + knock = File.join(path_to_resources, 'knock44.wav') + else + knock = File.join(path_to_resources, 'knock48.wav') + end + + log.debug("knock file path: " + knock) + knock + end + + def create_silence(tmp_dir, segment_count, duration) + file = File.join(tmp_dir, "#{segment_count}.wav") + + # -c 2 means stereo + cmd("sox -n -r #{long_sample_rate} -c 2 #{file} trim 0.0 #{duration}", "silence") + + file + end + + def create_tapin_track(tmp_dir) + + return nil if @start_points.length == 0 + + segment_count = 0 + + + #initial_silence = @initial_tap_in + @initial_padding + + initial_silence = @tap_in_initial_silence + + #log.info("tapin data: initial_tap_in: #{@initial_tap_in}, initial_padding: #{@initial_padding}, initial_silence: #{initial_silence}") + + time_points = [] + files = [] + if initial_silence > 0 + + files << create_silence(tmp_dir, segment_count, initial_silence) + + time_points << {type: :silence, ts: initial_silence} + segment_count += 1 + end + + + time_cursor = nil + @start_points.each do |start_point| + tap_time = parse_time(start_point["ts"]) + if !time_cursor.nil? + between_silence = tap_time - time_cursor + files << create_silence(tmp_dir, segment_count, between_silence) + time_points << {type: :silence, ts: between_silence} + end + time_cursor = tap_time + bpm = start_point["bpm"].to_f + + tick_silence = 60.0/bpm - KNOCK_SECONDS + + ticks = start_point["ticks"].to_i + + ticks.times do |tick| + files << knock_file + files << create_silence(tmp_dir, segment_count, tick_silence) + time_points << {type: :knock, ts: KNOCK_SECONDS} + time_points << {type: :silence, ts: tick_silence} + time_cursor + 60.0/bpm + segment_count += 1 + end + end + + log.info("time points for tap-in: #{time_points.inspect}") + # do we need to pad with time? not sure + + sequence_cmd = "sox " + files.each do |file| + sequence_cmd << "\"#{file}\" " + end + + count_in = File.join(tmp_dir, "count-in.wav") + sequence_cmd << "\"#{count_in}\"" + + cmd(sequence_cmd, "count_in") + @count_in_file = count_in + count_in + end + # creates a list of tracks to actually mix def track_settings altered_tracks = @settings["tracks"] || [] @@ -113,6 +347,15 @@ module JamRuby stems = @mixdown.jam_track.stem_tracks @track_count = stems.length + @include_count_in = @settings["count-in"] && @start_points.length > 0 && @mixdown_package.encrypt_type.nil? + + # temp + # @include_count_in = true + + if @include_count_in + @track_count += 1 + end + stems.each do |stem| vol = 1.0 @@ -139,10 +382,14 @@ module JamRuby # if we didn't deliberately skip this one, and if there was no 'match' (meaning user did not specify), then we leave this in unchanged if !skipped && !match - @track_settings << {stem:stem, vol:vol, pan:pan} + @track_settings << {stem: stem, vol: vol, pan: pan} end end + if @include_count_in + @track_settings << {count_in: true, vol: 1.0, pan: 0} + end + @track_settings end @@ -153,14 +400,14 @@ module JamRuby # k = f(i) = (i)/(2*MAX_PAN) + 0.5 # so f(MIN_PAN) = -0.5 + 0.5 = 0 - k = ((pan * (1.0))/ (2.0 * MAX_PAN )) + 0.5 + k = ((pan * (1.0))/ (2.0 * MAX_PAN)) + 0.5 l, r = 0 if k == 0 l = 0.0 r = 1.0 else - l = Math.sqrt(k) + l = Math.sqrt(k) r = Math.sqrt(1-k) end @@ -169,24 +416,26 @@ module JamRuby def package - puts @settings.inspect - puts @track_count - puts @track_settings - puts @track_settings.count + log.info("Settings: #{@settings.to_json}") Dir.mktmpdir do |tmp_dir| # download all files @track_settings.each do |track| - jam_track_track = track[:stem] - file = File.join(tmp_dir, jam_track_track.id + '.ogg') + if track[:count_in] + file = create_tapin_track(tmp_dir) + bump_step(@mixdown_package) + else + jam_track_track = track[:stem] - bump_step(@mixdown_package) + file = File.join(tmp_dir, jam_track_track.id + '.ogg') - # download each track needed - s3_manager.download(jam_track_track.url_by_sample_rate(@mixdown_package.sample_rate), file) + bump_step(@mixdown_package) + # download each track needed + s3_manager.download(jam_track_track.url_by_sample_rate(@mixdown_package.sample_rate), file) + end track[:file] = file end @@ -206,6 +455,8 @@ module JamRuby apply_vol_and_pan tmp_dir + create_silence_padding tmp_dir + mix tmp_dir pitch_speed tmp_dir @@ -218,6 +469,7 @@ module JamRuby @track_settings.each do |track| jam_track_track = track[:stem] + count_in = track[:count_in] file = track[:file] unless should_alter_volume? track @@ -235,7 +487,11 @@ module JamRuby # sox claps.wav claps-remixed.wav remix 1v1.0 2v1.0 - volumed_file = File.join(tmp_dir, jam_track_track.id + '-volumed.ogg') + if count_in + volumed_file = File.join(tmp_dir, 'count-in' + '-volumed.ogg') + else + volumed_file = File.join(tmp_dir, jam_track_track.id + '-volumed.ogg') + end cmd("sox \"#{file}\" \"#{volumed_file}\" remix 1v#{channel_r} 2v#{channel_l}", 'vol_pan') @@ -244,6 +500,29 @@ module JamRuby end end + def create_silence_padding(tmp_dir) + if @initial_padding > 0 && @include_count_in + + @padding_file = File.join(tmp_dir, "initial_padding.ogg") + + # -c 2 means stereo + cmd("sox -n -r #{long_sample_rate} -c 2 #{@padding_file} trim 0.0 #{@initial_padding}", "initial_padding") + + @track_settings.each do |track| + + next if track[:count_in] + + input = track[:volumed_file] + output = input[0..-5] + '-padded.ogg' + + padd_cmd = "sox '#{@padding_file}' '#{input}' '#{output}'" + + cmd(padd_cmd, "pad_track_with_silence") + track[:volumed_file] = output + end + end + end + # output is @mix_file def mix(tmp_dir) @@ -251,6 +530,11 @@ module JamRuby @mix_file = File.join(tmp_dir, "mix.ogg") + + pitch = @settings['pitch'] || 0 + speed = @settings['speed'] || 0 + + # if there is only one track to mix, we need to skip mixing (sox will barf if you try to mix one file), but still divide by number of tracks if @track_settings.count == 1 mix_divide = 1.0/@track_count @@ -263,6 +547,11 @@ module JamRuby cmd = "sox -m" mix_divide = 1.0/@track_count @track_settings.each do |track| + + # if pitch/shifted, we lay the tap-in after pitch/speed shift + # next if (pitch != 0 || speed != 0) && track[:count_in] + next if track[:count_in] + volumed_file = track[:volumed_file] cmd << " -v #{mix_divide} \"#{volumed_file}\"" end @@ -275,6 +564,13 @@ module JamRuby end + def long_sample_rate + sample_rate = 48000 + if @mixdown_package.sample_rate != 48 + sample_rate = 44100 + end + sample_rate + end # output is @speed_mix_file def pitch_speed tmp_dir @@ -300,17 +596,21 @@ module JamRuby # usage: sbsms infile<.wav|.aif|.mp3|.ogg> outfile<.ogg> rate[0.01:100] halfsteps[-48:48] outSampleRateInHz - sample_rate = 48000 - if @mixdown_package.sample_rate != 48 - sample_rate = 44100 - end + sample_rate = long_sample_rate # rate comes in as a percent (like 5, -5 for 5%, -5%). We need to change that to 1.05/ sbsms_speed = speed/100.0 sbsms_speed = 1.0 + sbsms_speed sbsms_pitch = pitch - cmd( "sbsms \"#{@mix_file}\" \"#{@speed_mix_file}\" #{sbsms_speed} #{sbsms_pitch} #{sample_rate}", 'speed_pitch_shift') + cmd("sbsms \"#{@mix_file}\" \"#{@speed_mix_file}\" #{sbsms_speed} #{sbsms_pitch} #{sample_rate}", 'speed_pitch_shift') + end + + if @include_count_in + # lay the tap-ins over the recording + layered = File.join(tmp_dir, "layered_speed_mix.ogg") + cmd("sox -m '#{@count_in_file}' '#{@speed_mix_file}' '#{layered}'", "layer_tap_in") + @speed_mix_file = layered end end @@ -337,7 +637,7 @@ module JamRuby length = File.size(output) computed_md5 = Digest::MD5.new - File.open(output, 'rb').each {|line| computed_md5.update(line)} + File.open(output, 'rb').each { |line| computed_md5.update(line) } md5 = computed_md5.to_s @mixdown_package.finish_sign(s3_url, private_key, length, md5.to_s) @@ -399,7 +699,7 @@ module JamRuby end private_key_file = File.join(tmp_dir, 'skey.pem') - File.open(private_key_file, 'w') {|f| f.write(private_key) } + File.open(private_key_file, 'w') { |f| f.write(private_key) } log.debug("PRIVATE KEY") log.debug(private_key) diff --git a/ruby/spec/factories.rb b/ruby/spec/factories.rb index c8c91241e..024ecdc20 100644 --- a/ruby/spec/factories.rb +++ b/ruby/spec/factories.rb @@ -19,6 +19,8 @@ FactoryGirl.define do terms_of_service true last_jam_audio_latency 5 reuse_card true + has_redeemable_jamtrack true + gifted_jamtracks 0 #u.association :musician_instrument, factory: :musician_instrument, user: u @@ -858,4 +860,18 @@ FactoryGirl.define do legalese Faker::Lorem.paragraphs(6).join("\n\n") end + factory :gift_card, class: 'JamRuby::GiftCard' do + sequence(:code) {n.to_s} + card_type JamRuby::GiftCardType::JAM_TRACKS_5 + end + + factory :gift_card_type, class: 'JamRuby::GiftCardType' do + card_type JamRuby::GiftCardType::JAM_TRACKS_5 + end + + factory :gift_card_purchase, class: 'JamRuby::GiftCardPurchase' do + + association :user, factory: :user + end + end diff --git a/ruby/spec/jam_ruby/models/jam_track_spec.rb b/ruby/spec/jam_ruby/models/jam_track_spec.rb index 814a4cbb3..4ed8e7b28 100644 --- a/ruby/spec/jam_ruby/models/jam_track_spec.rb +++ b/ruby/spec/jam_ruby/models/jam_track_spec.rb @@ -234,6 +234,17 @@ describe JamTrack do query.size.should == 2 end + + it "deals with aggregration (regression)" do + + query, pager, count = JamTrack.index({sort_by: 'jamtrack', artist: 'K.C. And The Sunshine Band'}, user) + count.should == 0 + + jam_track1 = FactoryGirl.create(:jam_track_with_tracks, name: 'Take a Chance On Me', original_artist: 'K.C. And The Sunshine Band') + + query, pager, count = JamTrack.index({sort_by: 'jamtrack', artist: 'K.C. And The Sunshine Band'}, user) + count.should == 1 + end end describe "validations" do diff --git a/ruby/spec/jam_ruby/models/recurly_transaction_web_hook_spec.rb b/ruby/spec/jam_ruby/models/recurly_transaction_web_hook_spec.rb index ba89aee20..bce945d20 100644 --- a/ruby/spec/jam_ruby/models/recurly_transaction_web_hook_spec.rb +++ b/ruby/spec/jam_ruby/models/recurly_transaction_web_hook_spec.rb @@ -135,7 +135,7 @@ describe RecurlyTransactionWebHook do RecurlyTransactionWebHook.create_from_xml(document) - JamTrackRight.find_by_id(jam_track_right.id).should be_nil + JamTrackRight.find_by_id(jam_track_right.id).should_not be_nil end it "deletes jam_track_right when voided" do @@ -154,7 +154,7 @@ describe RecurlyTransactionWebHook do RecurlyTransactionWebHook.create_from_xml(document) - JamTrackRight.find_by_id(jam_track_right.id).should be_nil + JamTrackRight.find_by_id(jam_track_right.id).should_not be_nil end end diff --git a/ruby/spec/jam_ruby/models/sale_line_item_spec.rb b/ruby/spec/jam_ruby/models/sale_line_item_spec.rb index 334166734..4d0340259 100644 --- a/ruby/spec/jam_ruby/models/sale_line_item_spec.rb +++ b/ruby/spec/jam_ruby/models/sale_line_item_spec.rb @@ -6,6 +6,7 @@ describe SaleLineItem do let(:user) {FactoryGirl.create(:user)} let(:user2) {FactoryGirl.create(:user)} let(:jam_track) {FactoryGirl.create(:jam_track)} + let(:gift_card) {FactoryGirl.create(:gift_card_type, card_type: GiftCardType::JAM_TRACKS_10)} describe "associations" do @@ -23,7 +24,7 @@ describe SaleLineItem do describe "state" do - it "success" do + it "jam track success" do sale = Sale.create_jam_track_sale(user) shopping_cart = ShoppingCart.create(user, jam_track) sale_line_item = SaleLineItem.create_from_shopping_cart(sale, shopping_cart, 'some_recurly_uuid', nil, nil) @@ -37,5 +38,20 @@ describe SaleLineItem do success: true }) end + + it "gift card success" do + sale = Sale.create_jam_track_sale(user) + shopping_cart = ShoppingCart.create(user, gift_card) + sale_line_item = SaleLineItem.create_from_shopping_cart(sale, shopping_cart, 'some_recurly_uuid', nil, nil) + transaction = FactoryGirl.create(:recurly_transaction_web_hook, subscription_id: 'some_recurly_uuid') + + sale_line_item.reload + sale_line_item.state.should eq({ + void: false, + refund: false, + fail: false, + success: true + }) + end end end diff --git a/ruby/spec/jam_ruby/models/sale_spec.rb b/ruby/spec/jam_ruby/models/sale_spec.rb index 685d8dfbd..fc89145cb 100644 --- a/ruby/spec/jam_ruby/models/sale_spec.rb +++ b/ruby/spec/jam_ruby/models/sale_spec.rb @@ -5,6 +5,24 @@ describe Sale do let(:user) {FactoryGirl.create(:user)} let(:user2) {FactoryGirl.create(:user)} let(:jam_track) {FactoryGirl.create(:jam_track)} + let(:jam_track2) {FactoryGirl.create(:jam_track)} + let(:jam_track3) {FactoryGirl.create(:jam_track)} + let(:gift_card) {GiftCardType.jam_track_5} + + def assert_free_line_item(sale_line_item, jamtrack) + sale_line_item.recurly_tax_in_cents.should be_nil + sale_line_item.recurly_total_in_cents.should be_nil + sale_line_item.recurly_currency.should be_nil + sale_line_item.recurly_discount_in_cents.should be_nil + sale_line_item.product_type.should eq(JamTrack::PRODUCT_TYPE) + sale_line_item.unit_price.should eq(jamtrack.price) + sale_line_item.quantity.should eq(1) + sale_line_item.free.should eq(1) + sale_line_item.sales_tax.should be_nil + sale_line_item.shipping_handling.should eq(0) + sale_line_item.recurly_plan_code.should eq(jamtrack.plan_code) + sale_line_item.product_id.should eq(jamtrack.id) + end describe "index" do it "empty" do @@ -47,7 +65,11 @@ describe Sale do let(:user) {FactoryGirl.create(:user)} let(:jamtrack) { FactoryGirl.create(:jam_track) } + let(:jamtrack2) { FactoryGirl.create(:jam_track) } + let(:jamtrack3) { FactoryGirl.create(:jam_track) } + let(:jamtrack4) { FactoryGirl.create(:jam_track) } let(:jam_track_price_in_cents) { (jamtrack.price * 100).to_i } + let(:gift_card_price_in_cents) { (gift_card.price * 100).to_i } let(:client) { RecurlyClient.new } let(:billing_info) { info = {} @@ -75,6 +97,77 @@ describe Sale do end end + it "for a gift card" do + shopping_cart = ShoppingCart.create user, gift_card, 1, false + client.find_or_create_account(user, billing_info) + + sales = Sale.place_order(user, [shopping_cart]) + + user.reload + user.sales.length.should eq(1) + + sales.should eq(user.sales) + sale = sales[0] + sale.recurly_invoice_id.should_not be_nil + + sale.recurly_subtotal_in_cents.should eq(gift_card_price_in_cents) + sale.recurly_tax_in_cents.should eq(0) + sale.recurly_total_in_cents.should eq(gift_card_price_in_cents) + sale.recurly_currency.should eq('USD') + + sale.order_total.should eq(gift_card.price) + sale.sale_line_items.length.should == 1 + sale_line_item = sale.sale_line_items[0] + # validate we are storing pricing info from recurly + sale_line_item.recurly_tax_in_cents.should eq(0) + sale_line_item.recurly_total_in_cents.should eq(gift_card_price_in_cents) + sale_line_item.recurly_currency.should eq('USD') + sale_line_item.recurly_discount_in_cents.should eq(0) + sale_line_item.product_type.should eq(GiftCardType::PRODUCT_TYPE) + sale_line_item.unit_price.should eq(gift_card.price) + sale_line_item.quantity.should eq(1) + sale_line_item.free.should eq(0) + sale_line_item.sales_tax.should be_nil + sale_line_item.shipping_handling.should eq(0) + sale_line_item.recurly_plan_code.should eq(gift_card.plan_code) + sale_line_item.product_id.should eq(gift_card.id) + sale_line_item.recurly_subscription_uuid.should be_nil + sale_line_item.recurly_adjustment_uuid.should_not be_nil + sale_line_item.recurly_adjustment_credit_uuid.should be_nil + sale_line_item.recurly_adjustment_uuid.should_not be_nil + + # verify subscription is in Recurly + recurly_account = client.get_account(user) + adjustments = recurly_account.adjustments + adjustments.should_not be_nil + adjustments.should have(1).items + purchase= adjustments[0] + purchase.unit_amount_in_cents.should eq((gift_card.price * 100).to_i) + purchase.accounting_code.should eq(ShoppingCart::PURCHASE_NORMAL) + purchase.description.should eq("JamTracks Gift Card (5)") + purchase.state.should eq('invoiced') + purchase.uuid.should eq(sale_line_item.recurly_adjustment_uuid) + + invoices = recurly_account.invoices + invoices.should have(1).items + invoice = invoices[0] + invoice.uuid.should eq(sale.recurly_invoice_id) + invoice.line_items.should have(1).items # should have single adjustment associated + invoice.line_items[0].should eq(purchase) + invoice.subtotal_in_cents.should eq((gift_card.price * 100).to_i) + invoice.total_in_cents.should eq((gift_card.price * 100).to_i) + invoice.state.should eq('collected') + + # verify jam_track_rights data + user.gift_card_purchases.should_not be_nil + user.gift_card_purchases.should have(1).items + user.gift_card_purchases.last.gift_card_type.should eq(GiftCardType.jam_track_5) + user.has_redeemable_jamtrack.should be_true + + sale_line_item.affiliate_referral.should be_nil + sale_line_item.affiliate_referral_fee_in_cents.should be_nil + end + it "for a free jam track" do shopping_cart = ShoppingCart.create user, jamtrack, 1, true @@ -87,6 +180,7 @@ describe Sale do sales.should eq(user.sales) sale = sales[0] + sale.recurly_invoice_id.should be_nil sale.recurly_subtotal_in_cents.should eq(0) @@ -132,6 +226,69 @@ describe Sale do user.has_redeemable_jamtrack.should be_false end + it "for two jam tracks (1 freebie, 1 gifted), then 1 gifted/1 pay" do + user.gifted_jamtracks = 2 + user.save! + + shopping_cart1 = ShoppingCart.create user, jamtrack, 1, true + shopping_cart2 = ShoppingCart.create user, jamtrack2, 1, true + + client.find_or_create_account(user, billing_info) + + sales = Sale.place_order(user, [shopping_cart1, shopping_cart2]) + + user.reload + user.sales.length.should eq(1) + sale = sales[0] + sale.reload + + sale.recurly_invoice_id.should be_nil + + sale.recurly_subtotal_in_cents.should eq(0) + sale.recurly_tax_in_cents.should eq(0) + sale.recurly_total_in_cents.should eq(0) + sale.recurly_currency.should eq('USD') + sale.order_total.should eq(0) + sale.sale_line_items.length.should == 2 + + assert_free_line_item(sale.sale_line_items[0], jamtrack) + assert_free_line_item(sale.sale_line_items[1], jamtrack2) + + # verify jam_track_rights data + right1 = JamTrackRight.where(user_id: user.id).where(jam_track_id: jamtrack.id).first + right2 = JamTrackRight.where(user_id: user.id).where(jam_track_id: jamtrack2.id).first + user.jam_track_rights.should have(2).items + + right1.redeemed.should be_true + right2.redeemed.should be_true + user.has_redeemable_jamtrack.should be_false + user.gifted_jamtracks.should eq(1) + + + + # OK! Now make a second purchase; this time, buy one free, one not free + shopping_cart3 = ShoppingCart.create user, jamtrack3, 1, true + + client.find_or_create_account(user, billing_info) + + sales = Sale.place_order(user, [shopping_cart3]) + + user.reload + user.sales.length.should eq(2) + sale = sales[0] + sale.reload + + sale.recurly_invoice_id.should be_nil + sale.recurly_subtotal_in_cents.should eq(0) + sale.recurly_tax_in_cents.should eq(0) + sale.recurly_total_in_cents.should eq(0) + sale.recurly_currency.should eq('USD') + sale.order_total.should eq(0) + sale.sale_line_items.length.should == 1 + + assert_free_line_item(sale.sale_line_items[0], jamtrack3) + end + it "for a free jam track with an affiliate association" do partner = FactoryGirl.create(:affiliate_partner) user.affiliate_referral = partner diff --git a/ruby/spec/jam_ruby/models/shopping_cart_spec.rb b/ruby/spec/jam_ruby/models/shopping_cart_spec.rb index 6be02e8d4..8d3b724b1 100644 --- a/ruby/spec/jam_ruby/models/shopping_cart_spec.rb +++ b/ruby/spec/jam_ruby/models/shopping_cart_spec.rb @@ -3,8 +3,15 @@ require 'spec_helper' describe ShoppingCart do let(:user) { FactoryGirl.create(:user) } - let(:jam_track) {FactoryGirl.create(:jam_track) } - let(:jam_track2) {FactoryGirl.create(:jam_track) } + let(:jam_track) { FactoryGirl.create(:jam_track) } + let(:jam_track2) { FactoryGirl.create(:jam_track) } + let(:jam_track3) { FactoryGirl.create(:jam_track) } + let(:jam_track4) { FactoryGirl.create(:jam_track) } + let(:jam_track5) { FactoryGirl.create(:jam_track) } + let(:jam_track6) { FactoryGirl.create(:jam_track) } + let(:jam_track7) { FactoryGirl.create(:jam_track) } + let(:gift_card) {FactoryGirl.create(:gift_card_type)} + let(:gift_card2) {FactoryGirl.create(:gift_card_type)} before(:each) do ShoppingCart.delete_all @@ -13,6 +20,9 @@ describe ShoppingCart do it "can reference a shopping cart" do shopping_cart = ShoppingCart.create user, jam_track, 1 + shopping_cart.errors.any?.should be_false + shopping_cart.valid?.should be_true + user.reload ShoppingCart.count.should == 1 user.shopping_carts.count.should == 1 user.shopping_carts[0].product_info[:name].should == jam_track.name @@ -21,18 +31,21 @@ describe ShoppingCart do user.shopping_carts[0].quantity.should == 1 end - - it "maintains only one fre JamTrack in ShoppingCart" do - cart1 = ShoppingCart.add_jam_track_to_cart(user, jam_track) + it "maintains only one free JamTrack in ShoppingCart" do + cart1 = ShoppingCart.add_jam_track_to_cart(user, jam_track, clear: true) cart1.should_not be_nil cart1.errors.any?.should be_false user.reload - cart2 = ShoppingCart.add_jam_track_to_cart(user, jam_track) + cart2 = ShoppingCart.add_jam_track_to_cart(user, jam_track, clear: true) cart2.errors.any?.should be_false user.reload user.shopping_carts.length.should eq(1) - cart3 = ShoppingCart.add_jam_track_to_cart(user, jam_track2) - cart3.errors.any?.should be_false + cart3 = ShoppingCart.add_item_to_cart(user, gift_card) + cart3.errors.any?.should be_true + user.reload + user.shopping_carts.length.should eq(1) + cart4 = ShoppingCart.add_jam_track_to_cart(user, jam_track2, clear: true) + cart4.errors.any?.should be_false user.reload user.shopping_carts.length.should eq(1) end @@ -48,24 +61,159 @@ describe ShoppingCart do cart2.errors.any?.should be_true end + it "a second giftcard just adds quantity" do + + end + describe "redeemable behavior" do it "removes redeemable item to shopping cart (maintains only one in cart)" do user.has_redeemable_jamtrack.should be_true + cart1 = ShoppingCart.add_jam_track_to_cart(user, jam_track, clear: true) + cart1.should_not be_nil + cart1.errors.any?.should be_false + cart1.marked_for_redeem.should eq(1) + user.reload + cart2 = ShoppingCart.add_jam_track_to_cart(user, jam_track2, clear: true) + cart2.should_not be_nil + cart2.errors.any?.should be_false + cart2.marked_for_redeem.should eq(1) + + ShoppingCart.find_by_id(cart1.id).should be nil + + + ShoppingCart.remove_jam_track_from_cart(user, cart2) + + user.reload + user.shopping_carts.length.should eq(0) + ShoppingCart.find_by_id(cart2.id).should be nil + end + end + + describe "multiple free jamtracks" do + + before(:each) do + user.gifted_jamtracks = 5 + user.save! + end + + it "user can add and remove jamtracks without issue, until 'mixed' free/non-free is hit" do cart1 = ShoppingCart.add_jam_track_to_cart(user, jam_track) cart1.should_not be_nil + cart1.errors.any?.should be_false + user.reload cart2 = ShoppingCart.add_jam_track_to_cart(user, jam_track2) - cart2.should_not be_nil - + cart2.errors.any?.should be_false + user.reload + user.shopping_carts.length.should eq(2) cart1.marked_for_redeem.should eq(1) cart2.marked_for_redeem.should eq(1) - ShoppingCart.remove_jam_track_from_cart(user, jam_track) - user.shopping_carts.length.should eq(0) - cart2.reload + cart3 = ShoppingCart.add_jam_track_to_cart(user, jam_track3) + cart3.errors.any?.should be_false + user.reload + user.shopping_carts.length.should eq(3) + cart1.marked_for_redeem.should eq(1) cart2.marked_for_redeem.should eq(1) + cart3.marked_for_redeem.should eq(1) + + cart4 = ShoppingCart.add_jam_track_to_cart(user, jam_track4) + cart4.errors.any?.should be_false + user.reload + user.shopping_carts.length.should eq(4) + cart1.marked_for_redeem.should eq(1) + cart2.marked_for_redeem.should eq(1) + cart3.marked_for_redeem.should eq(1) + cart4.marked_for_redeem.should eq(1) + + cart5 = ShoppingCart.add_jam_track_to_cart(user, jam_track5) + cart5.errors.any?.should be_false + user.reload + user.shopping_carts.length.should eq(5) + cart1.marked_for_redeem.should eq(1) + cart2.marked_for_redeem.should eq(1) + cart3.marked_for_redeem.should eq(1) + cart4.marked_for_redeem.should eq(1) + cart5.marked_for_redeem.should eq(1) + + cart6 = ShoppingCart.add_jam_track_to_cart(user, jam_track6) + cart6.errors.any?.should be_false + user.reload + user.shopping_carts.length.should eq(6) + cart1.marked_for_redeem.should eq(1) + cart2.marked_for_redeem.should eq(1) + cart3.marked_for_redeem.should eq(1) + cart4.marked_for_redeem.should eq(1) + cart5.marked_for_redeem.should eq(1) + cart6.marked_for_redeem.should eq(1) + + cart7 = ShoppingCart.add_jam_track_to_cart(user, jam_track7) + cart7.errors.any?.should be_true + user.reload + user.shopping_carts.length.should eq(6) + cart1.marked_for_redeem.should eq(1) + cart2.marked_for_redeem.should eq(1) + cart3.marked_for_redeem.should eq(1) + cart4.marked_for_redeem.should eq(1) + cart5.marked_for_redeem.should eq(1) + cart6.marked_for_redeem.should eq(1) + end + end + + describe "gift cards" do + it "can not add multiple of same type" do + cart1 = ShoppingCart.add_item_to_cart(user, gift_card) + cart1.should_not be_nil + cart1.errors.any?.should be_false + + user.reload + user.has_redeemable_jamtrack = true + user.shopping_carts.length.should eq(1) + user.shopping_carts[0].quantity.should eql(1) + + cart2 = ShoppingCart.add_item_to_cart(user, gift_card) + cart2.should_not be_nil + # it's the same type, so it's blocked + cart2.errors.any?.should be_true + cart2.errors[:cart_id].should eq(["has already been taken"]) + end + end + + describe "mixed" do + it "non-free then free" do + # you shouldn't be able to add a free after a non-free + user.has_redeemable_jamtrack = false + user.save! + + cart1 = ShoppingCart.add_jam_track_to_cart(user, jam_track) + cart1.should_not be_nil + cart1.errors.any?.should be_false + + user.has_redeemable_jamtrack = true + user.save! + user.reload + cart2 = ShoppingCart.add_jam_track_to_cart(user, jam_track2) + cart2.errors.any?.should be_true + cart2.errors[:base].should eq(["You can not add a free JamTrack to a cart with non-free items. Please clear out your cart."]) + + user.shopping_carts.length.should eq(1) + end + + it "free then non-free" do + + cart1 = ShoppingCart.add_jam_track_to_cart(user, jam_track) + cart1.should_not be_nil + cart1.errors.any?.should be_false + + user.reload + + cart2 = ShoppingCart.add_jam_track_to_cart(user, jam_track2) + cart2.errors.any?.should be_true + cart2.errors[:base].should eq(["You can not add a non-free JamTrack to a cart containing free items. Please clear out your cart."]) + + user.shopping_carts.length.should eq(1) end end end diff --git a/ruby/spec/spec_helper.rb b/ruby/spec/spec_helper.rb index 93ec5dda7..7f189e159 100644 --- a/ruby/spec/spec_helper.rb +++ b/ruby/spec/spec_helper.rb @@ -95,13 +95,13 @@ end config.before(:suite) do DatabaseCleaner.strategy = :transaction - DatabaseCleaner.clean_with(:deletion, {pre_count: true, reset_ids:false, :except => %w[instruments genres icecast_server_groups jamcompany jamisp geoipblocks geoipisp geoiplocations cities regions countries generic_state spatial_ref_sys] }) + DatabaseCleaner.clean_with(:deletion, {pre_count: true, reset_ids:false, :except => %w[gift_card_types instruments genres icecast_server_groups jamcompany jamisp geoipblocks geoipisp geoiplocations cities regions countries generic_state spatial_ref_sys] }) end config.around(:each) do |example| # set no_transaction: true as metadata on your test to use deletion strategy instead if example.metadata[:no_transaction] - DatabaseCleaner.strategy = :deletion, {pre_count: true, reset_ids:false, :except => %w[instruments genres icecast_server_groups jamcompany jamisp geoipblocks geoipisp geoiplocations cities regions countries generic_state spatial_ref_sys] } + DatabaseCleaner.strategy = :deletion, {pre_count: true, reset_ids:false, :except => %w[gift_card_types instruments genres icecast_server_groups jamcompany jamisp geoipblocks geoipisp geoiplocations cities regions countries generic_state spatial_ref_sys] } else DatabaseCleaner.strategy = :transaction end diff --git a/web/app/assets/images/landing/gift_card.png b/web/app/assets/images/landing/gift_card.png new file mode 100644 index 000000000..e652e81db Binary files /dev/null and b/web/app/assets/images/landing/gift_card.png differ diff --git a/web/app/assets/images/web/button_cta_jamblaster.png b/web/app/assets/images/web/button_cta_jamblaster.png index 8650fe322..aed1fab4a 100644 Binary files a/web/app/assets/images/web/button_cta_jamblaster.png and b/web/app/assets/images/web/button_cta_jamblaster.png differ diff --git a/web/app/assets/images/web/button_cta_jamtrack.png b/web/app/assets/images/web/button_cta_jamtrack.png index 998d89b75..d8dd6e40c 100644 Binary files a/web/app/assets/images/web/button_cta_jamtrack.png and b/web/app/assets/images/web/button_cta_jamtrack.png differ diff --git a/web/app/assets/images/web/button_cta_platform.png b/web/app/assets/images/web/button_cta_platform.png index dba8d499b..a2ddf74ef 100644 Binary files a/web/app/assets/images/web/button_cta_platform.png and b/web/app/assets/images/web/button_cta_platform.png differ diff --git a/web/app/assets/javascripts/accounts_profile_avatar.js b/web/app/assets/javascripts/accounts_profile_avatar.js index 63d1aca1f..2ab8858cd 100644 --- a/web/app/assets/javascripts/accounts_profile_avatar.js +++ b/web/app/assets/javascripts/accounts_profile_avatar.js @@ -40,8 +40,8 @@ var template= context.JK.fillTemplate($('#template-account-profile-avatar').html(), { "fp_apikey" : gon.fp_apikey, "data-fp-store-path" : createStorePath(userDetail) + createOriginalFilename(userDetail), - "fp_policy" : filepicker_policy.policy, - "fp_signature" : filepicker_policy.signature + "fp_policy" : encodeURIComponent(filepicker_policy.policy), + "fp_signature" : encodeURIComponent(filepicker_policy.signature) }); $('#account-profile-avatar-content-scroller').html(template); @@ -202,7 +202,6 @@ renderNoAvatar(avatarSpace); } else { - rest.getFilepickerPolicy({handle: fpfile.url}) .done(function(filepickerPolicy) { avatarSpace.children().remove(); diff --git a/web/app/assets/javascripts/backend_alerts.js b/web/app/assets/javascripts/backend_alerts.js index bf5b1993b..2bd2b3737 100644 --- a/web/app/assets/javascripts/backend_alerts.js +++ b/web/app/assets/javascripts/backend_alerts.js @@ -137,6 +137,9 @@ else if(type === ALERT_NAMES.VIDEO_WINDOW_CLOSED) { context.VideoActions.videoWindowClosed() } + else if (type === ALERT_NAMES.VST_CHANGED) { + context.ConfigureTracksActions.onVstChanged() + } else if((!context.JK.CurrentSessionModel || !context.JK.CurrentSessionModel.inSession()) && (ALERT_NAMES.INPUT_IO_RATE == type || ALERT_NAMES.INPUT_IO_JTR == type || ALERT_NAMES.OUTPUT_IO_RATE == type || ALERT_NAMES.OUTPUT_IO_JTR== type)) { // squelch these events if not in session diff --git a/web/app/assets/javascripts/checkout_complete.js b/web/app/assets/javascripts/checkout_complete.js index 4f1e96110..aa52214b9 100644 --- a/web/app/assets/javascripts/checkout_complete.js +++ b/web/app/assets/javascripts/checkout_complete.js @@ -15,6 +15,7 @@ var $templatePurchasedJamTrack = null; var $thanksPanel = null; var $jamTrackInBrowser = null; + var $giftCardPurchased = null; var $purchasedJamTrack = null; var $purchasedJamTrackHeader = null; var $purchasedJamTracks = null; @@ -75,9 +76,17 @@ else { $thanksPanel.removeClass('hidden') handleJamTracksPurchased(purchaseResponse.jam_tracks) + handleGiftCardsPurchased(purchaseResponse.gift_cards) } } + + function handleGiftCardsPurchased(gift_cards) { + // were any GiftCards purchased? + if(gift_cards && gift_cards.length > 0) { + $giftCardPurchased.removeClass('hidden') + } + } function handleJamTracksPurchased(jamTracks) { // were any JamTracks purchased? var jamTracksPurchased = jamTracks && jamTracks.length > 0; @@ -194,6 +203,7 @@ $templatePurchasedJamTrack = $('#template-purchased-jam-track'); $thanksPanel = $screen.find(".thanks-panel"); $jamTrackInBrowser = $screen.find(".thanks-detail.jam-tracks-in-browser"); + $giftCardPurchased = $screen.find('.thanks-detail.gift-card') $purchasedJamTrack = $thanksPanel.find(".thanks-detail.purchased-jam-track"); $purchasedJamTrackHeader = $purchasedJamTrack.find(".purchased-jam-track-header"); $purchasedJamTracks = $purchasedJamTrack.find(".purchased-list") diff --git a/web/app/assets/javascripts/checkout_order.js b/web/app/assets/javascripts/checkout_order.js index 168b965d6..a69c0a39c 100644 --- a/web/app/assets/javascripts/checkout_order.js +++ b/web/app/assets/javascripts/checkout_order.js @@ -135,15 +135,7 @@ } } - function displayTax(effectiveQuantity, item_tax, total_with_tax) { - var totalTax = 0; - var totalPrice = 0; - - var unitTax = item_tax * effectiveQuantity; - totalTax += unitTax; - - var totalUnitPrice = total_with_tax * effectiveQuantity; - totalPrice += totalUnitPrice; + function displayTax(totalTax, totalPrice) { $screen.find('.order-right-page .order-items-value.taxes').text('$' + totalTax.toFixed(2)) $screen.find('.order-right-page .order-items-value.grand-total').text('$' + totalPrice.toFixed(2)) @@ -181,8 +173,16 @@ taxRate = 0.0825; } - var unitTax = 1.99 * taxRate; - displayTax(effectiveQuantity, unitTax, 1.99 + unitTax) + var estimatedTax = 0; + var estimatedTotal = 0; + + context._.each(carts, function(cart) { + var cart_quantity = cart.product_info.quantity - cart.product_info.marked_for_redeem + estimatedTax += cart.product_info.price * cart_quantity * taxRate; + estimatedTotal += cart.product_info.price * cart_quantity; + }) + + displayTax(Math.round(estimatedTax*100)/100, Math.round((estimatedTotal + estimatedTax)*100)/100) } else { checkoutUtils.configureRecurly() diff --git a/web/app/assets/javascripts/checkout_payment.js b/web/app/assets/javascripts/checkout_payment.js index 9b72f4fc5..956c11886 100644 --- a/web/app/assets/javascripts/checkout_payment.js +++ b/web/app/assets/javascripts/checkout_payment.js @@ -95,7 +95,7 @@ $reuseExistingCardChk.iCheck(userDetail.reuse_card && userDetail.has_recurly_account ? 'check' : 'uncheck').attr('checked', userDetail.reuse_card) // show appropriate prompt text based on whether user has a free jamtrack - if(user.free_jamtrack) { + if(user.has_redeemable_jamtrack) { $freeJamTrackPrompt.removeClass('hidden') } else { diff --git a/web/app/assets/javascripts/checkout_utils.js.coffee b/web/app/assets/javascripts/checkout_utils.js.coffee index c16e09f9b..c789ba71d 100644 --- a/web/app/assets/javascripts/checkout_utils.js.coffee +++ b/web/app/assets/javascripts/checkout_utils.js.coffee @@ -55,6 +55,16 @@ class CheckoutUtils return carts[0].product_info.free + hasOnlyFreeItemsInShoppingCart: (carts) => + if carts.length == 0 + return false + + for cart in carts + if !cart.product_info.free + return false + + return true + configureRecurly: () => unless @configuredRecurly context.recurly.configure(gon.global.recurly_public_api_key) diff --git a/web/app/assets/javascripts/clientUpdate.js b/web/app/assets/javascripts/clientUpdate.js index ca5bdd428..dd3142e76 100644 --- a/web/app/assets/javascripts/clientUpdate.js +++ b/web/app/assets/javascripts/clientUpdate.js @@ -61,7 +61,10 @@ }) } - app.layout.showDialog('client-update') + if(!app.layout.isDialogShowing('client-update')) { + app.layout.showDialog('client-update') + } + //$('#client_update').show() //$('#client_update_overlay').show() } @@ -192,6 +195,11 @@ function runCheck(product, version, uri, size, currentVersion) { + if (app.clientUpdating) { + logger.debug("client is already updating; skipping") + return + } + if(currentVersion === undefined) { currentVersion = context.jamClient.ClientUpdateVersion(); @@ -302,7 +310,7 @@ $(document).on(EVENTS.SESSION_ENDED, function(e, data){ if(app.clientUpdating) { - updateClientUpdateDialog("update-start", { uri: updateUri }) + updateClientUpdateDialog("update-start", { uri: updateUri}) } }); diff --git a/web/app/assets/javascripts/dialog/gettingStartedDialog.js b/web/app/assets/javascripts/dialog/gettingStartedDialog.js index 867a411f2..aa35e80e7 100644 --- a/web/app/assets/javascripts/dialog/gettingStartedDialog.js +++ b/web/app/assets/javascripts/dialog/gettingStartedDialog.js @@ -50,7 +50,7 @@ $browserJamTrackBtn.click(function() { app.layout.closeDialog('getting-started') - window.location = '/client#/jamtrack/search' + window.location = '/client#/jamtrack' return false; }) @@ -69,9 +69,9 @@ function beforeShow() { app.user().done(function(user) { - var jamtrackRule = user.free_jamtrack ? 'has-free-jamtrack' : 'no-free-jamtrack' + var jamtrackRule = user.has_redeemable_jamtrack ? 'has-free-jamtrack' : 'no-free-jamtrack' $jamTrackSection.removeClass('has-free-jamtrack').removeClass('no-free-jamtrack').addClass(jamtrackRule) - if(user.free_jamtrack) { + if(user.has_redeemable_jamtrack) { $jamTracksLimitedTime.removeClass('hidden') } }) diff --git a/web/app/assets/javascripts/download_jamtrack.js.coffee b/web/app/assets/javascripts/download_jamtrack.js.coffee index c4727631d..eb9846546 100644 --- a/web/app/assets/javascripts/download_jamtrack.js.coffee +++ b/web/app/assets/javascripts/download_jamtrack.js.coffee @@ -369,8 +369,8 @@ context.JK.DownloadJamTrack = class DownloadJamTrack @trackDetail = context.jamClient.JamTrackGetTrackDetail ("#{@jamTrack.id}-#{@sampleRateForFilename}") if @trackDetail.version? - @logger.error("after invalidating package, the version is still wrong!") - throw "after invalidating package, the version is still wrong!" + @logger.error("after invalidating package, the version is still wrong!", @trackDetail) + throw "after invalidating package, the version is still wrong! #{@trackDetail.version}" switch @trackDetail.key_state when 'pending' diff --git a/web/app/assets/javascripts/globals.js b/web/app/assets/javascripts/globals.js index c085e548b..8c5895a7f 100644 --- a/web/app/assets/javascripts/globals.js +++ b/web/app/assets/javascripts/globals.js @@ -126,7 +126,8 @@ RECORDING_DONE :48, //the recording writer thread is done VIDEO_WINDOW_OPENED :49, //video window opened VIDEO_WINDOW_CLOSED :50, - LAST_ALERT : 51 + VST_CHANGED: 51, // VST state changed + LAST_ALERT : 52 } // recreate eThresholdType enum from MixerDialog.h context.JK.ALERT_TYPES = { @@ -190,7 +191,8 @@ 48: {"title": "", "message": ""}, // RECORDING_DONE 49: {"title": "", "message": ""}, // VIDEO_WINDOW_OPENED 50: {"title": "", "message": ""}, // VIDEO_WINDOW_CLOSED - 51: {"title": "", "message": ""} // LAST_ALERT + 51: {"title": "", "message": ""}, // VST_CHANGED + 52: {"title": "", "message": ""} // LAST_ALERT }; // add the alert's name to the ALERT_TYPES structure diff --git a/web/app/assets/javascripts/jam_rest.js b/web/app/assets/javascripts/jam_rest.js index 2dcaabfc3..10461d496 100644 --- a/web/app/assets/javascripts/jam_rest.js +++ b/web/app/assets/javascripts/jam_rest.js @@ -1187,6 +1187,7 @@ }); deferred.done(function(user) { + context.JK.currentUserFreeJamTrack = user.show_free_jamtrack window.UserActions.loaded(user) }) @@ -1791,12 +1792,28 @@ } function addJamtrackToShoppingCart(options) { - return $.ajax({ + var deferred = $.ajax({ type: "POST", url: '/api/shopping_carts/add_jamtrack?' + $.param(options), dataType: "json", contentType: 'application/json' }); + + deferred.done(function(response) { + window.UserActions.modify(response) + }) + return deferred + } + + function addGiftCardToShoppingCart(options) { + var deferred = $.ajax({ + type: "POST", + url: '/api/shopping_carts/add_gift_card?' + $.param(options), + dataType: "json", + contentType: 'application/json' + }); + + return deferred } function getShoppingCarts() { @@ -1810,12 +1827,17 @@ } function removeShoppingCart(options) { - return $.ajax({ + var deferred = $.ajax({ type: "DELETE", url: '/api/shopping_carts?' + $.param(options), dataType: "json", contentType: 'application/json' }) + + deferred.done(function(response) { + window.UserActions.modify(response) + }) + return deferred } function clearShoppingCart(options) { @@ -1986,6 +2008,17 @@ }); } + function redeemGiftCard(data) { + var id = getId(data); + return $.ajax({ + type: "POST", + url: '/api/users/' + id + '/gift_cards', + dataType: "json", + contentType: 'application/json', + data: JSON.stringify(data), + }); + } + function portOverCarts() { return $.ajax({ type: "POST", @@ -2166,6 +2199,7 @@ this.enqueueJamTrack = enqueueJamTrack; this.getBackingTracks = getBackingTracks; this.addJamtrackToShoppingCart = addJamtrackToShoppingCart; + this.addGiftCardToShoppingCart = addGiftCardToShoppingCart; this.getShoppingCarts = getShoppingCarts; this.removeShoppingCart = removeShoppingCart; this.clearShoppingCart = clearShoppingCart; @@ -2190,6 +2224,7 @@ this.playJamTrack = playJamTrack; this.createSignupHint = createSignupHint; this.createAlert = createAlert; + this.redeemGiftCard = redeemGiftCard; this.signup = signup; this.portOverCarts = portOverCarts; return this; diff --git a/web/app/assets/javascripts/jam_track_screen.js.coffee b/web/app/assets/javascripts/jam_track_screen.js.coffee deleted file mode 100644 index bb0c2fa2b..000000000 --- a/web/app/assets/javascripts/jam_track_screen.js.coffee +++ /dev/null @@ -1,484 +0,0 @@ -$ = jQuery -context = window -context.JK ||= {} - -context.JK.JamTrackScreen=class JamTrackScreen - LIMIT = 10 - instrument_logo_map = context.JK.getInstrumentIconMap24() - - constructor: (@app) -> - @EVENTS = context.JK.EVENTS - @logger = context.JK.logger - @screen = null - @content = null - @scroller = null - @genre = null - @artist = null - @instrument = null - @availability = null - @nextPager = null - @noMoreJamtracks = null - @currentPage = 0 - @next = null - @currentQuery = this.defaultQuery() - @expanded = null - @shownHelperBubbles = false - - beforeShow:(data) => - this.setFilterFromURL() - - if context.JK.currentUserId? - @app.user().done((user) => - @user = user - this.refresh() - ).fail((arg) => - @logger.error("app.user.done failed: " + JSON.stringify(arg)) - - @logger.debug(arg.statusCode); - - throw 'fail should not occur if user is available' - ) - else - this.refresh() - unless @shownHelperBubbles - @shownHelperBubbles = true - @startHelperBubbles() - - afterShow:(data) => - context.JK.Tracking.jamtrackBrowseTrack(@app) - - beforeHide: () => - this.clearCtaHelpTimeout() - this.clearBandFilterHelpTimeout() - this.clearMasterHelpTimeout() - this.clearResults(); - - events:() => - @genre.on 'change', this.search - @artist.on 'change', this.search - @instrument.on 'change', this.search - @availability.on 'change', this.search - - clearResults:() => - @currentPage = 0 - @content.empty() - @noMoreJamtracks.hide() - @next = null - - startHelperBubbles: () => - @showBandFilterHelpTimeout = setTimeout(@showBandFilterHelp, 3500) - - showBandFilterHelp: () => - context.JK.HelpBubbleHelper.jamtrackBrowseBand(@artist.closest('.easydropdown-wrapper'), $('body')) - - @showMasterHelpDueTime = new Date().getTime() + 11000 # 6000 ms for band tooltip to display, and 5 seconds of quiet time - @scroller.on('scroll', @masterHelpScrollWatch) - @scroller.on('scroll', @clearBubbles) - @showMasterHelpTimeout = setTimeout(@showMasterHelp, @masterHelpDueTime()) - - clearBubbles: () => - if @helpBubble? - @helpBubble.btOff() - @helpBubble = null - - # computes when we should show the master help bubble - masterHelpDueTime: () => - dueTime = @showMasterHelpDueTime - new Date().getTime() - if dueTime <= 0 - dueTime = 2000 - dueTime - - - # computes when we should show the master help bubble - ctaHelpDueTime: () => - dueTime = @showCtaHelpDueTime - new Date().getTime() - if dueTime <= 0 - dueTime = 2000 - dueTime - - # if the user scrolls, reset the master help due time - masterHelpScrollWatch: () => - @clearMasterHelpTimeout() - @showMasterHelpTimeout = setTimeout(@showMasterHelp, @masterHelpDueTime() + 2000) - - # if the user scrolls, reset the master help due time - ctaHelpScrollWatch: () => - @clearCtaHelpTimeout() - @showCtaHelpTimeout = setTimeout(@showCtaHelp, @ctaHelpDueTime() + 2000) - - - showCtaHelp: () => - @scroller.off('scroll', @ctaHelpScrollWatch) - @clearCtaHelpTimeout() - - cutoff = @scroller.offset().top; - - @screen.find('.jamtrack-actions').each((i, element) => - $element = $(element) - - if ($element.offset().top >= cutoff) - @helpBubble = context.JK.HelpBubbleHelper.jamtrackBrowseCta($element, $('body')) - return false - else - return true - ) - - showMasterHelp: () => - @scroller.off('scroll', @masterHelpScrollWatch) - @clearMasterHelpTimeout() - - # don't show the help if the user has already clicked a preview - unless @userPreviewed - cutoff = @scroller.offset().top; - - @screen.find('.jamtrack-preview[data-track-type="Master"]').each((i, element) => - $element = $(element) - - if ($element.offset().top >= cutoff) - @helpBubble = context.JK.HelpBubbleHelper.jamtrackBrowseMasterMix($element.find('.play-button'), $('body')) - return false - else - return true - ) - - @showCtaHelpDueTime = new Date().getTime() + 11000 - @scroller.on('scroll', @ctaHelpScrollWatch) - @showCtaHelpTimeout = setTimeout(@showCtaHelp, @ctaHelpDueTime()) # 6000 ms for bubble show time, and 5000ms for delay - - previewPlayed: () => - @userPreviewed = true - - clearCtaHelpTimeout:() => - if @showCtaHelpTimeout? - clearTimeout(@showCtaHelpTimeout) - @showCtaHelpTimeout = null - - clearBandFilterHelpTimeout: () => - if @showBandFilterHelpTimeout? - clearTimeout(@showBandFilterHelpTimeout) - @showBandFilterHelpTimeout = null - - clearMasterHelpTimeout: () => - if @showMasterHelpTimeout? - clearTimeout(@showMasterHelpTimeout) - @showMasterHelpTimeout = null - - setFilterFromURL:() => - # Grab parms from URL for artist, instrument, and availability - parms=this.getParams() - - if(parms.artist?) - @artist.val(parms.artist) - else - @artist.val('') - if(parms.instrument?) - @instrument.val(parms.instrument) - else - @instrument.val('') - if(parms.availability?) - @availability.val(parms.availability) - else - @availability.val('') - - if window.history.replaceState #ie9 proofing - window.history.replaceState({}, "", "/client#/jamtrackBrowse") - - getParams:() => - params = {} - q = window.location.href.split("?")[1] - if q? - q = q.split('#')[0] - raw_vars = q.split("&") - for v in raw_vars - [key, val] = v.split("=") - params[key] = decodeURIComponent(val) - params - - setFilterState: (state) => - if state - @genre.easyDropDown('enable').removeAttr('disabled') - @artist.easyDropDown('enable').removeAttr('disabled') - @instrument.easyDropDown('enable').removeAttr('disabled') - @availability.easyDropDown('enable').removeAttr('disabled') - else - @genre.easyDropDown('disable').attr('disabled', 'disabled') - @artist.easyDropDown('disable').attr('disabled', 'disabled') - @instrument.easyDropDown('disable').attr('disabled', 'disabled') - @availability.easyDropDown('disable').attr('disabled', 'disabled') - - refresh:() => - this.clearResults() - @currentQuery = this.buildQuery() - that = this - this.setFilterState(false) - rest.getJamTracks(@currentQuery).done((response) => - that.handleJamtrackResponse(response) - ).fail( (jqXHR) => - that.clearResults() - that.noMoreJamtracks.show() - that.app.notifyServerError jqXHR, 'Jamtrack Unavailable' - ).always () => - that.setFilterState(true) - - search:() => - this.refresh() - false - - defaultQuery:() => - query = - per_page: LIMIT - page: @currentPage+1 - if @next - query.since = @next - query - - buildQuery:() => - @currentQuery = this.defaultQuery() - # genre filter - # var genres = @screen.find('#jamtrack_genre').val() - # if (genres !== undefined) { - # @currentQuery.genre = genres - # } - # instrument filter - - instrument = @instrument.val() - if instrument? - @currentQuery.instrument = instrument - - # artist filter - art = @artist.val() - if art? - @currentQuery.artist = art - - # availability filter - availability = @availability.val() - if availability? - @currentQuery.availability = availability - @currentQuery - - handleJamtrackResponse:(response) => - @next = response.next - this.renderJamtracks(response) - if response.next == null - # if we less results than asked for, end searching - @scroller.infinitescroll 'pause' - if @currentPage == 0 and response.jamtracks.length == 0 - @content.append '