Production release 4.8.2

app/controllers/api/v1/feeds_controller.rb

@@ -44,6 +44,18 @@ def index
       @feeds = @feeds.geometry_within_bbox(params[:bbox])
     end
 
+    if params[:active_feed_version_valid].present?
+      @feeds = @feeds.where_active_feed_version_valid(params[:active_feed_version_valid])
+    end
+
+    if params[:active_feed_version_expired].present?
+      @feeds = @feeds.where_active_feed_version_expired(params[:active_feed_version_expired])
+    end
+
+    if params[:active_feed_version_update].presence == 'true'
+      @feeds = @feeds.where_active_feed_version_update
+    end
+
     respond_to do |format|
       format.json do
         render paginated_json_collection(
@@ -54,7 +66,14 @@ def index
           params[:offset],
           params[:per_page],
           params[:total],
-          params.slice(:tag_key, :tag_value)
+          params.slice(
+            :tag_key,
+            :tag_value,
+            :last_imported_since,
+            :active_feed_version_valid,
+            :active_feed_version_expired,
+            :active_feed_version_update
+          )
         )
       end
       format.geojson do

app/controllers/api/v1/operators_controller.rb

@@ -32,6 +32,8 @@ def index
     @operators = AllowFiltering.by_attribute_array(@operators, params, :state)
     @operators = AllowFiltering.by_attribute_array(@operators, params, :metro)
     @operators = AllowFiltering.by_attribute_array(@operators, params, :timezone)
+    @operators = AllowFiltering.by_attribute_array(@operators, params, :name)
+    @operators = AllowFiltering.by_attribute_array(@operators, params, :short_name)
 
     if [params[:lat], params[:lon]].map(&:present?).all?
       point = Operator::GEOFACTORY.point(params[:lon], params[:lat])
@@ -71,7 +73,9 @@ def index
             :onestop_id,
             :tag_key,
             :tag_value,
-            :import_level
+            :import_level,
+            :name,
+            :short_name
           )
         )
       end
@@ -103,12 +107,16 @@ def aggregate
         state: {},
         metro: {},
         timezone: {},
+        name: {},
+        short_name: {},
         tags: {}
       }
       json[:country] = count_values(Operator.pluck(:country), attr_name: :country)
       json[:state] = count_values(Operator.pluck(:state), attr_name: :state)
       json[:metro] = count_values(Operator.pluck(:metro), attr_name: :metro)
       json[:timezone] = count_values(Operator.pluck(:timezone), attr_name: :timezone)
+      json[:name] = count_values(Operator.pluck(:name), attr_name: :name)
+      json[:short_name] = count_values(Operator.pluck(:short_name), attr_name: :short_name)
       json[:tags] = count_and_gather_values(Operator.pluck(:tags))
       json
     end

app/models/feed.rb

@@ -73,6 +73,38 @@ class Feed < BaseFeed
 
   after_initialize :set_default_values
 
+  scope :where_active_feed_version_valid, -> (date) {
+    date = date.is_a?(Date) ? date : Date.parse(date)
+    joins(:active_feed_version)
+      .where('feed_versions.latest_calendar_date > ?', date)
+      .where('feed_versions.earliest_calendar_date < ?', date)
+  }
+
+  scope :where_active_feed_version_expired, -> (date) {
+    date = date.is_a?(Date) ? date : Date.parse(date)
+    joins(:active_feed_version)
+      .where('feed_versions.latest_calendar_date < ?', date)
+  }
+
+  scope :where_active_feed_version_update, -> {
+    # Find feeds that have a feed_version newer than
+    #   the current active_feed_version
+    joins(p %{
+      INNER JOIN (
+        SELECT DISTINCT feed_versions.feed_id
+        FROM feed_versions
+        INNER JOIN (
+          SELECT feed_versions.feed_id AS feed_id, feed_versions.created_at AS created_at_active
+          FROM feed_versions
+          INNER JOIN current_feeds ON current_feeds.active_feed_version_id = feed_versions.id
+          GROUP BY feed_versions.feed_id, feed_versions.created_at
+        ) feed_versions_active ON feed_versions.feed_id = feed_versions_active.feed_id
+        WHERE feed_versions.created_at > feed_versions_active.created_at_active
+      ) feeds_superseded
+      ON current_feeds.id = feeds_superseded.feed_id
+    })
+  }
+
   include CurrentTrackedByChangeset
   current_tracked_by_changeset({
     kind_of_model_tracked: :onestop_entity,

app/models/feed_version.rb

@@ -44,6 +44,10 @@ class FeedVersion < ActiveRecord::Base
 
   before_validation :compute_and_set_hashes, :read_gtfs_calendar_dates, :read_gtfs_feed_info
 
+  scope :where_active, -> {
+    joins('INNER JOIN current_feeds ON feed_versions.id = current_feeds.active_feed_version_id')
+  }
+
   def succeeded(timestamp)
     self.update(imported_at: timestamp)
     self.feed.update(last_imported_at: self.imported_at)

app/services/gtfs_graph.rb

@@ -75,10 +75,10 @@ def create_change_osr
       changeset.create_change_payloads(routes)
       log "  route geometries: #{rsps.size}"
       changeset.create_change_payloads(rsps)
-    rescue ChangesetError => e
+    rescue Changeset::Error => e
       log "Error: #{e.message}"
       log "Payload:"
-      e.change_payloads.each do |change_payload|
+      changeset.change_payloads.each do |change_payload|
         log change_payload.to_json
       end
     end

spec/controllers/api/v1/operators_controller_spec.rb

@@ -30,6 +30,26 @@
         }})
       end
 
+      it 'filters by name' do
+        operators = create_list(:operator, 3)
+        operator = create(:operator, name: 'Test 123')
+        get :index, name: operator.name
+        expect_json({ operators: -> (operators) {
+          expect(operators.first[:onestop_id]).to eq operator.onestop_id
+          expect(operators.count).to eq 1
+        }})
+      end
+
+      it 'filters by short_name' do
+        operators = create_list(:operator, 3)
+        operator = create(:operator, short_name: 'Test 123')
+        get :index, short_name: operator.short_name
+        expect_json({ operators: -> (operators) {
+          expect(operators.first[:onestop_id]).to eq operator.onestop_id
+          expect(operators.count).to eq 1
+        }})
+      end
+
       it 'returns the appropriate operator when identifier provided' do
         get :index, identifier: 'VTA'
         expect_json({ operators: -> (operators) {

spec/models/feed_spec.rb

@@ -321,4 +321,63 @@
       expect(feed.active_feed_version).to eq(fv2)
     end
   end
+
+  context '.where_active_feed_version_valid' do
+    before(:each) do
+      date0 = Date.parse('2014-01-01')
+      date1 = Date.parse('2015-01-01')
+      date2 = Date.parse('2016-01-01')
+      feed = create(:feed)
+      fv1 = create(:feed_version, feed: feed, earliest_calendar_date: date0, latest_calendar_date: date1)
+      fv2 = create(:feed_version, feed: feed, earliest_calendar_date: date1, latest_calendar_date: date2)
+      feed.update(active_feed_version: fv2)
+    end
+
+    it 'finds valid active_feed_version' do
+      expect(Feed.where_active_feed_version_valid('2015-06-01').count).to eq(1)
+    end
+
+    it 'expired active_feed_version' do
+      expect(Feed.where_active_feed_version_valid('2016-06-01').count).to eq(0)
+    end
+
+    it 'active_feed_version that has not started' do
+      expect(Feed.where_active_feed_version_valid('2014-06-01').count).to eq(0)
+    end
+  end
+
+  context '.where_newer_feed_version' do
+    before(:each) do
+      date0 = Date.parse('2014-01-01')
+      date1 = Date.parse('2015-01-01')
+      date2 = Date.parse('2016-01-01')
+      # 3 feed versions, 2 newer
+      @feed0 = create(:feed)
+      fv0 = create(:feed_version, feed: @feed0, created_at: date0)
+      fv1 = create(:feed_version, feed: @feed0, created_at: date1)
+      fv2 = create(:feed_version, feed: @feed0, created_at: date2)
+      @feed0.update!(active_feed_version: fv0)
+      # 3 feed versions, 1 newer, 1 older
+      @feed1 = create(:feed)
+      fv3 = create(:feed_version, feed: @feed1, created_at: date0)
+      fv4 = create(:feed_version, feed: @feed1, created_at: date1)
+      fv5 = create(:feed_version, feed: @feed1, created_at: date2)
+      @feed1.update!(active_feed_version: fv4)
+      # 3 feed versions, 2 newer
+      @feed2 = create(:feed)
+      fv6 = create(:feed_version, feed: @feed2, created_at: date0)
+      fv7 = create(:feed_version, feed: @feed2, created_at: date1)
+      fv8 = create(:feed_version, feed: @feed2, created_at: date2)
+      @feed2.update!(active_feed_version: fv8)
+      # 1 feed version, current
+      @feed3 = create(:feed)
+      fv9 = create(:feed_version, feed: @feed3, created_at: date0)
+      @feed3.update!(active_feed_version: fv9)
+    end
+
+    it 'finds superseded feeds' do
+      expect(Feed.where_active_feed_version_update).to match_array([@feed0, @feed1])
+    end
+  end
+
 end