245 lines
8.4 KiB
Ruby
245 lines
8.4 KiB
Ruby
class ApiSearchController < ApiController
|
|
|
|
# have to be signed in currently to see this screen
|
|
before_filter :api_signed_in_user, :except => :jam_tracks
|
|
|
|
respond_to :json
|
|
|
|
include LatencyHelper
|
|
|
|
def index
|
|
if 1 == params[Search::PARAM_MUSICIAN].to_i || 1 == params[Search::PARAM_BAND].to_i
|
|
query = params.clone
|
|
query[:remote_ip] = request.remote_ip
|
|
if 1 == query[Search::PARAM_MUSICIAN].to_i
|
|
@search = Search.musician_filter(query, current_user)
|
|
else
|
|
@search = Search.band_filter(query, current_user)
|
|
end
|
|
respond_with @search, responder: ApiResponder, :status => 200
|
|
elsif 1 == params[Search::PARAM_SESSION_INVITE].to_i
|
|
@search = Search.session_invite_search(params[:query], current_user)
|
|
else
|
|
@search = Search.text_search(params, current_user)
|
|
end
|
|
end
|
|
|
|
def musicians
|
|
if request.get?
|
|
if params[:results]
|
|
@search = MusicianSearch.user_search_filter(current_user).search_results_page
|
|
respond_with @search, responder: ApiResponder, status: 201, template: 'api_search/index'
|
|
else
|
|
render :json => MusicianSearch.search_filter_json(current_user), :status => 200
|
|
end
|
|
|
|
elsif request.post?
|
|
sobj = MusicianSearch.user_search_filter(current_user)
|
|
filter = params[:filter]
|
|
if filter == 'reset'
|
|
@search = sobj.reset_search_results
|
|
else
|
|
json = JSON.parse(filter, :create_additions => false)
|
|
@search = sobj.search_results_page(json, [params[:page].to_i, 1].max)
|
|
end
|
|
respond_with @search, responder: ApiResponder, status: 201, template: 'api_search/index'
|
|
end
|
|
end
|
|
|
|
def bands
|
|
if request.get?
|
|
if params[:results]
|
|
@search = BandSearch.user_search_filter(current_user).search_results_page(params[:subtype])
|
|
respond_with @search, responder: ApiResponder, status: 201, template: 'api_search/index'
|
|
else
|
|
render :json => BandSearch.search_filter_json(current_user, params[:subtype]), :status => 200
|
|
end
|
|
|
|
elsif request.post?
|
|
sobj = BandSearch.user_search_filter(current_user)
|
|
filter = params[:filter]
|
|
if filter == 'reset'
|
|
@search = sobj.reset_search_results(params[:subtype])
|
|
else
|
|
json = JSON.parse(filter, :create_additions => false)
|
|
@search = sobj.search_results_page(params[:subtype], json, [params[:page].to_i, 1].max)
|
|
end
|
|
respond_with @search, responder: ApiResponder, status: 201, template: 'api_search/index'
|
|
end
|
|
end
|
|
|
|
def jam_tracks
|
|
if request.get?
|
|
if params[:iso639]
|
|
render(json: JamTrackSearch.all_languages.to_json, status: 200)
|
|
|
|
elsif params[:indexed]
|
|
fname = "#{Rails.root}/tmp/jtx_indices.json"
|
|
|
|
unless File.exists?(fname) && File.size(fname) > 0
|
|
SampleApp::Application.load_tasks
|
|
Rake::Task["mobile:jam_tracks_json"].invoke
|
|
end
|
|
json = JSON.parse(File.read(fname))
|
|
render(json: json, status: 200)
|
|
|
|
else
|
|
render(json: {})
|
|
end
|
|
|
|
elsif request.post?
|
|
jts = JamTrackSearch.new
|
|
filter = request.params[:api_search]
|
|
result = jts.search_results_page(filter)
|
|
render(json: result.to_json, status: 200)
|
|
end
|
|
end
|
|
|
|
#Filter users by first fetching users from latency graph database
|
|
#for latency specific filter options and then query the postgresql relational
|
|
#database for other filter options
|
|
def filter
|
|
latency_good = ActiveRecord::Type::Boolean.new.type_cast_from_user(params[:latency_good])
|
|
latency_fair = ActiveRecord::Type::Boolean.new.type_cast_from_user(params[:latency_fair])
|
|
latency_high = ActiveRecord::Type::Boolean.new.type_cast_from_user(params[:latency_high])
|
|
|
|
begin
|
|
@latency_data = users_latency_data(latency_good, latency_fair, latency_high)
|
|
#debugger
|
|
user_ids = @latency_data.map{ |l_data| l_data[:user_id] }
|
|
|
|
filter_params = {
|
|
"sort_order"=>"latency",
|
|
"instruments"=>[],
|
|
"genres"=> [],
|
|
"concert_gigs"=>"-1",
|
|
"interests"=>"any",
|
|
"studio_sessions"=>"-1",
|
|
"ages"=>[],
|
|
"skill_level"=>"-1",
|
|
"joined_within_days"=>"any"
|
|
}
|
|
|
|
filter_params.merge!(genres: params[:genres]) unless params[:genres].blank?
|
|
|
|
beginner = ActiveRecord::Type::Boolean.new.type_cast_from_user(params[:proficiency_beginner])
|
|
intermediate = ActiveRecord::Type::Boolean.new.type_cast_from_user(params[:proficiency_intermediate])
|
|
expert = ActiveRecord::Type::Boolean.new.type_cast_from_user(params[:proficiency_expert])
|
|
|
|
proficiency_levels = []
|
|
proficiency_levels.push(1) if beginner
|
|
proficiency_levels.push(2) if intermediate
|
|
proficiency_levels.push(3) if expert
|
|
|
|
instruments = params[:instruments]
|
|
|
|
if instruments && instruments.any?
|
|
inst = []
|
|
instruments.each do |ii|
|
|
proficiency_levels.each do |pl|
|
|
inst << { instrument_id: ii, proficiency_level: pl}
|
|
end
|
|
end
|
|
filter_params.merge!(instruments: inst)
|
|
end
|
|
|
|
filter_params.merge!(joined_within_days: params[:joined_within_days]) unless params[:joined_within_days].blank?
|
|
|
|
sobj = MusicianSearch.user_search_filter(current_user)
|
|
@search = sobj.search_results_page(filter_params, [params[:page].to_i, 1].max, user_ids)
|
|
|
|
respond_with @search, responder: ApiResponder, status: 201, template: 'api_search/index'
|
|
|
|
rescue => exception
|
|
logger.debug("Latency exception: #{exception.message}")
|
|
Bugsnag.notify(exception) do |report|
|
|
report.severity = "error"
|
|
report.add_tab(:latency, {
|
|
params: params,
|
|
user_id: current_user.id,
|
|
name: current_user.name,
|
|
url: filter_latency_url,
|
|
})
|
|
end
|
|
render json: {}, status: 500
|
|
end
|
|
|
|
end
|
|
|
|
private
|
|
|
|
def filter_latency_url
|
|
"#{Rails.application.config.latency_data_host}/search_users"
|
|
end
|
|
|
|
# def users_latency_data(latency_good, latency_fair, latency_high)
|
|
# latency_data = []
|
|
# if latency_good || latency_fair || latency_high
|
|
# uri = URI(filter_latency_url)
|
|
# begin
|
|
# http = Net::HTTP.new(uri.host, uri.port)
|
|
# http.use_ssl = true if Rails.application.config.latency_data_host.start_with?("https://")
|
|
# req = Net::HTTP::Post.new(uri)
|
|
# req["Authorization"] = "Basic #{Rails.application.config.latency_data_host_auth_code}"
|
|
# req["Content-Type"] = "application/json"
|
|
# req.body = {
|
|
# my_user_id: current_user.id,
|
|
# my_public_ip: request.remote_ip,
|
|
# my_device_id: nil,
|
|
# my_client_id: nil
|
|
# }.to_json
|
|
|
|
# response = http.request(req)
|
|
|
|
# if response.is_a?(Net::HTTPOK) || response.is_a?(Net::HTTPSuccess)
|
|
# graph_db_users = JSON.parse(response.body)["users"]
|
|
# if latency_good || latency_fair || latency_high
|
|
# graph_db_users.select! do |user|
|
|
# total_latency = user["ars"]["total_latency"].to_f
|
|
# (total_latency >= 0 && total_latency <= 40 && latency_good) ||
|
|
# (total_latency > 40 && total_latency <= 80 && latency_fair) ||
|
|
# (total_latency > 80 && latency_high)
|
|
# end
|
|
# end
|
|
|
|
# latency_data = graph_db_users.map { | user |
|
|
# total = user["ars"]["total_latency"].to_f
|
|
# label = if total >= 0 && total <= 40
|
|
# 'good'
|
|
# elsif total > 40 && total <= 80
|
|
# 'fair'
|
|
# else
|
|
# 'high'
|
|
# end
|
|
# {
|
|
# user_id: user["user_id"],
|
|
# audio_latency: user["audio_latency"].to_f,
|
|
# ars_total_latency: user["ars"]["total_latency"].to_f,
|
|
# ars_internet_latency: user["ars"]["internet_latency"].to_f
|
|
# }
|
|
# }.uniq
|
|
# #debugger
|
|
# return latency_data
|
|
# else
|
|
# logger.debug("Latency response failed: #{response}")
|
|
# Bugsnag.notify("LatencyResponseFailed") do |report|
|
|
# report.severity = "faliure"
|
|
# report.add_tab(:latency, {
|
|
# user_id: current_user.id,
|
|
# name: current_user.name,
|
|
# params: params,
|
|
# url: filter_latency_url,
|
|
# code: response.code,
|
|
# body: response.body,
|
|
# })
|
|
# end
|
|
# end
|
|
# rescue => exception
|
|
# raise exception
|
|
# end
|
|
# end
|
|
# latency_data
|
|
# end
|
|
|
|
end
|