congress.rb

#!/usr/bin/env ruby

require './config/environment'
require './api/sunlight'
require './api/rss'

include Api::Routes
helpers Api::Helpers

get queryable_route do
  check_key!

  model = params[:captures][0].singularize.camelize.constantize rescue nil
  format = format_for params
  fields = fields_for model, params
  filters = filters_for model, params
  order = order_for params, Queryable.default_sort(model).nil? ? "_id" : Queryable.default_sort(model)

  # allow a pagination exception for legislators and committees, by request
  if [Legislator, Committee].include?(model) and (params[:per_page] == "all")
    pagination = {page: nil, per_page: nil}
  else
    pagination = pagination_for params
  end

  query_string = query_string_for params

  conditions = Queryable.conditions_for model, query_string, filters, params

  if params[:explain] == 'true'
    results = Queryable.explain_for model, conditions, fields, order, pagination
  else
    criteria = Queryable.criteria_for model, conditions, fields, order, pagination
    documents = Queryable.documents_for model, criteria, fields
    results = Queryable.results_for criteria, documents, pagination
    results[:results] = Citable.add_to(model, results[:results], params) if results[:results]
  end

  hit! "query", format

  if format == 'json'
    json results
  elsif format == 'rss'
    rss results, model, params
  elsif format == 'rss-json'
    jss results, model, params
  elsif format == 'xml'
    xml results
  end
end


get searchable_route do
  check_key!

  models = params[:captures][0].split(",").map {|m| m.singularize.camelize.constantize rescue nil}.compact
  format = format_for params
  fields = fields_for models, params
  pagination = pagination_for params
  filters = filters_for models, params
  order = order_for params, "_score"

  search_fields = Searchable.search_fields_for models
  profiles = Searchable.profiles_for models, params

  # query is actually optional, these may both end up null
  query_string = query_string_for params
  query = Searchable.query_for query_string, params, search_fields

  filter = Searchable.filter_for filters
  other = Searchable.other_options_for params, search_fields


  if params[:explain] == 'true'
    results = Searchable.explain_for query_string, models, query, filter, fields, order, pagination, profiles, other
  else
    results = Searchable.search_for query_string, models, query, filter, fields, order, pagination, profiles, other
    results[:results] = Citable.add_to(models, results[:results], params) if results[:results]
  end

  hit! "search", format

  if format == 'json'
    json results
  elsif format == 'rss'
    rss results, models, params
  elsif format == 'rss-json'
    jss results, model, params
  elsif format == 'xml'
    xml results
  end
end


# special endpoints for doing lat/lng and zip-based lookups on legislators and districts
# uses mix of methods to return information, using helper methods in Location module

get(/(legislators|districts)\/locate\/?/) do
  check_key!

  error 400, "Provide a 'zip', or a 'latitude' and 'longitude'." unless params[:zip] or (params[:latitude] and params[:longitude])

  begin
    if params[:zip]
      if zip = Zip.where(zip: params[:zip]).first
        districts = zip['districts']
        location = {zip: params[:zip], districts: zip['districts']}
      else
        districts = []
      end

      details = {zip: params[:zip]}
    elsif params[:latitude] and params[:longitude]
      url = Location.url_for params[:latitude], params[:longitude]

      start = Time.now
      response = Location.response_for url
      elapsed = Time.now - start

      districts = Location.response_to_districts response

      location = {latitude: params[:latitude], longitude: params[:longitude], response: response, elapsed: elapsed, districts: districts}
    end
  rescue Location::LocationException => ex
    error 500, ex.message
  end

  if params[:captures][0] == "legislators"
    if districts.any?
      model = Legislator
      fields = fields_for model, params
      pagination = pagination_for params
      order = order_for params, "_id"
      conditions = Location.district_to_legislators districts

      if params[:explain] == 'true'
        explain = Queryable.explain_for model, conditions, fields, order, pagination
        results = {location: location, query: explain}
      else
        criteria = Queryable.criteria_for model, conditions, fields, order, pagination
        documents = Queryable.documents_for model, criteria, fields
        results = Queryable.results_for criteria, documents, pagination
      end
    else # districts
      if params[:explain]
        results = {location: location}
      else
        results = {results: [], count: 0}
      end
    end

  else # districts
    if params[:explain]
      results = {location: location, districts: districts}
    else
      results = {results: districts, count: districts.size}
    end
  end

  hit! "locate", "json"

  json results
end

get '/' do
  result = {}

  if request.env['HTTP_X_FORWARDED_PROTO'] == 'http'
    result[:please_use_the_https_endpoint_at] = "https://congress.api.sunlightfoundation.com"
    result[:please] = "https://congress.api.sunlightfoundation.com"
  elsif request.env['HTTP_X_FORWARDED_PROTO'] == 'https'
    result[:thank_you] = "for using https"
  end

  json(result.merge(
    status: 200,
    message: "I live!",
    documentation: "https://sunlightlabs.github.io/congress/",
    code: "https://github.com/sunlightlabs/congress",
    report_bugs: "https://github.com/sunlightlabs/congress/issues",
    more_apis: "http://sunlightfoundation.com/api/"
  ))
end


# error handler and test
get '/error' do
  raise Exception.new("KABOOM.")
end

error do
  exception = env['sinatra.error']
  name = exception.class.name
  message = exception.message

  request = {
    method: env['REQUEST_METHOD'],
    url: env['REQUEST_URI'],
    params: params.inspect,
    user_agent: env['HTTP_USER_AGENT']
  }

  Email.report Report.exception("Exception Notifier", "#{name}: #{message}", exception, request: request)
  halt 500
end


helpers do

  def json(results)
    response['Content-Type'] = 'application/json; charset=utf-8'
    json = Oj.dump results, mode: :compat, time_format: :ruby
    if jsonp?
      "#{params[:callback]}(#{json});"
    else
      json
    end
  end

  def jsonp?
    !!(params[:callback].present?) and (params[:callback] =~ /^[\.a-zA-Z0-9\$_]+$/)
  end

  def xml(results)
    response['Content-Type'] = 'application/xml; charset=utf-8'
    results.to_xml root: 'results', dasherize: false
  end

  def error(status, message)
    format = format_for params

    results = {
      error: message,
      status: status
    }

    if format == "json"
      halt( (jsonp? ? 200 : status), json(results))
    else
      halt status, xml(results)
    end
  end

  def check_key!
    if Environment.check_key? and !ApiKey.allowed?(api_key)
      error 403, 'API key required, you can obtain one from http://services.sunlightlabs.com/accounts/register/'
    end
  end

  def api_key
    params[:apikey] || request.env['HTTP_X_APIKEY']
  end

  def hit!(method_type, format)
    return if params[:explain]

    method = params[:captures][0]
    key = api_key || "debug"
    now = Time.zone.now

    extras = {}

    if method_type == "locate"
      if params[:zip]
        method += ".zip"
        extras[:zip] = params[:zip]
      elsif params[:latitude] and params[:longitude]
        method += ".latlng"
        # Specifically do NOT store latitude and longitude.
        # We promise this in our API documentation.
      end
    elsif method_type == "search"
      method += ".search"
      extras[:query] = params[:query]
    end

    hit = Hit.create!(
      key: key,

      method: method,
      method_type: method_type,
      format: format,

      extras: extras,

      protocol: request.env['HTTP_X_FORWARDED_PROTO'],
      user_agent: request.env['HTTP_USER_AGENT'],
      app_version: request.env['HTTP_X_APP_VERSION'],
      os_version: request.env['HTTP_X_OS_VERSION'],
      app_channel: request.env['HTTP_X_APP_CHANNEL'],

      created_at: now.utc,
      elapsed: ((now - request.env['timer']) * 1000000).to_i
    )

    HitReport.log! now.strftime("%Y-%m-%d"), key, method
    SearchReport.log! extras[:query], method if extras[:query]
  end

end

before {request.env['timer'] = Time.now}

before do
  NewRelic::Agent.add_custom_parameters(
    endpoint: request.path_info,
    params: clean_params(params.clone)
  )
end