rollout-ui 0.10.0 → 0.11.0

data/lib/rollout/ui/web.rb

@@ -2,6 +2,7 @@ require "erb"
 require "json"
 require "rack"
 require "rollout"
+require "set"
 
 require "rollout/ui/version"
 require "rollout/ui/config"
@@ -30,6 +31,14 @@ module Rollout::UI
     class Dispatcher
       include Helpers
 
+      class StaleFeature < StandardError
+      end
+
+      class InvalidEnrollment < StandardError
+      end
+
+      STALE_FEATURE_MESSAGE = 'This rollout changed since you opened it. Your update was not saved. Review the latest state and try again.'
+
       VIEWS_PATH = File.expand_path('views', __dir__)
       TEMPLATE_CACHE = {}
       HISTORY_USER_LOOKUP_LIMIT = 150
@@ -37,6 +46,8 @@ module Rollout::UI
       ROUTES = [
         [:GET, %r{\A/\z}, :index],
         [:GET, %r{\A/users/search\z}, :search_users],
+        [:GET, %r{\A/features/(?<feature_name>[^/]+)/users/search\z}, :search_feature_users],
+        [:GET, %r{\A/features/(?<feature_name>[^/]+)/users\z}, :enrolled_users],
         [:GET, %r{\A/features/new\z}, :new_feature],
         [:POST, %r{\A/features/new\z}, :create_feature],
         [:POST, %r{\A/features/(?<feature_name>[^/]+)/activate-percentage\z}, :activate_percentage],
@@ -88,6 +99,7 @@ module Rollout::UI
             end
           )
         else
+          load_defined_features
           @history_events = @rollout.respond_to?(:logging) ? @rollout.logging.global_events.reverse : []
           load_history_user_nicknames(@history_events)
           render_view(:'features/index')
@@ -103,19 +115,32 @@ module Rollout::UI
       end
 
       def show
+        response['cache-control'] = 'no-store'
         @rollout = config.get(:instance)
         @feature = @rollout.get(params[:feature_name])
 
         if json_request?
           json(feature_to_hash(@feature))
         else
-          load_selected_users if user_selector_enabled? && @feature.users.count <= USER_EDIT_LIMIT
+          load_defined_features
+          load_selected_users
           @history_events = @rollout.respond_to?(:logging) ? @rollout.logging.events(@feature.name).reverse : []
           load_history_user_nicknames(@history_events)
           render_view(:'features/show')
         end
       end
 
+      def load_defined_features
+        names = if config.defined?(:defined_features)
+          config.get(:defined_features)
+        elsif Rollout.respond_to?(:definitions)
+          path = Rollout.definitions_path
+          Rollout.definitions.keys if path && File.directory?(path)
+        end
+
+        @defined_features = names.map(&:to_s).to_set unless names.nil?
+      end
+
       def search_users
         return not_found unless user_selector_enabled?
 
@@ -141,11 +166,91 @@ module Rollout::UI
         end
       end
 
+      def search_feature_users
+        return not_found unless user_selector_enabled?
+
+        response['cache-control'] = 'no-store'
+        @rollout = config.get(:instance)
+        begin
+          @feature = @rollout.get(params[:feature_name])
+        rescue StandardError
+          return not_found
+        end
+
+        query = params[:q]
+        unless query.nil? || query.is_a?(String)
+          response.status = 400
+          return json(error: 'Nickname must be a string.')
+        end
+        query = query.to_s.strip
+        if query.length > USER_SEARCH_MAX_LENGTH
+          response.status = 400
+          return json(error: "Nickname must be at most #{USER_SEARCH_MAX_LENGTH} characters.")
+        end
+        return json(users: [], feature_version: feature_version(@feature)) if query.length < user_search_min_length
+
+        enrolled_ids = @feature.users.map(&:to_s)
+        begin
+          users = config.get(:user_search, query, user_search_limit)
+          json(
+            users: users.take(user_search_limit).map do |user|
+              hashed = user_to_hash(user)
+              hashed.merge(enrolled: enrolled_ids.include?(hashed[:id]))
+            end,
+            feature_version: feature_version(@feature),
+          )
+        rescue StandardError
+          response.status = 503
+          json(error: 'Nickname search is temporarily unavailable. Please try again.')
+        end
+      end
+
+      def enrolled_users
+        response['cache-control'] = 'no-store'
+        @rollout ||= config.get(:instance)
+        begin
+          @feature = @rollout.get(params[:feature_name])
+        rescue StandardError
+          return not_found
+        end
+        load_selected_users
+
+        json(
+          users: @selected_users,
+          total: @users_total_count,
+          page: @user_page,
+          per_page: @users_per_page,
+          total_pages: @users_total_pages,
+          feature_version: feature_version(@feature),
+          lookup_failed: @selected_user_lookup_failed || false,
+        )
+      end
+
       def load_selected_users
-        ids = @feature.users.map(&:to_s)
-        lookup_user_nicknames(ids)
-        @selected_users = ids.map { |id| { id: id, nickname: user_label(id) } }
-        @selected_user_lookup_failed = @user_lookup_failed
+        @users_per_page = USER_PAGE_SIZE
+        all_ids = @feature.users.map { |id| id.to_s }.uniq.sort
+        @users_total_count = all_ids.size
+        @users_total_pages = [ (all_ids.size.to_f / @users_per_page).ceil, 1 ].max
+        @user_page = parse_users_page(params[:page], @users_total_pages)
+        offset = (@user_page - 1) * @users_per_page
+        page_ids = all_ids[offset, @users_per_page] || []
+        if config.defined?(:user_lookup)
+          lookup_user_nicknames(page_ids)
+        end
+        @selected_users = page_ids.map { |id| { id: id, nickname: user_label(id, include_id: false) } }
+        @selected_user_lookup_failed = @user_lookup_failed == true
+      end
+
+      def parse_users_page(value, total_pages)
+        candidate = 1
+        unless value.is_a?(Array) || value.is_a?(Hash)
+          raw = value.to_s.strip
+          candidate = raw.to_i if raw.match?(/\A\d+\z/)
+        end
+        candidate = 1 if candidate < 1
+        candidate = total_pages if candidate > total_pages
+        candidate = 1 if candidate < 1
+        candidate
       end
 
       def load_history_user_nicknames(events)
@@ -170,6 +275,8 @@ module Rollout::UI
       end
 
       def lookup_user_nicknames(ids)
+        return unless config.defined?(:user_lookup)
+
         @user_nicknames ||= {}
         @user_lookup_attempted ||= {}
         missing_ids = ids.uniq.reject { |id| @user_lookup_attempted.key?(id) }
@@ -195,26 +302,97 @@ module Rollout::UI
       end
 
       def update
+        enrollment = parse_enrollment!
         rollout = config.get(:instance)
         actor = config.get(:actor, scope: self)
-        feature_data = rollout.get(params[:feature_name]).data
-        if feature_data['updated_at'] && params[:last_updated_at].to_s != feature_data['updated_at'].to_s
-          return redirect_to("#{feature_path(params[:feature_name])}?error=Rollout version outdated. Review changes below and try again.")
-        end
 
         with_rollout_context(rollout, actor: actor) do
           rollout.with_feature(params[:feature_name]) do |feature|
+            validate_feature_version!(feature, enrollment)
             feature.percentage = params[:percentage].to_f.clamp(0.0, 100.0)
             feature.groups = (params[:groups] || []).reject(&:empty?).map(&:to_sym)
-            if params[:users]
-              feature.users = params[:users].split(',').map(&:strip).reject(&:empty?).uniq.sort
-            end
+            apply_enrollment!(feature, enrollment)
             feature.data["description"] = params[:description]
             feature.data["updated_at"] = Time.now.to_i
           end
         end
 
-        redirect_to feature_path(params[:feature_name])
+        redirect_location = feature_path(params[:feature_name])
+        if params.key?(:page)
+          after_feature = config.get(:instance).get(params[:feature_name])
+          total_pages = [ (after_feature.users.map(&:to_s).uniq.size.to_f / USER_PAGE_SIZE).ceil, 1 ].max
+          page = parse_users_page(params[:page], total_pages)
+          redirect_location = "#{feature_path(params[:feature_name])}?#{Rack::Utils.build_query('page' => page)}"
+        end
+        redirect_to redirect_location
+      rescue StaleFeature => error
+        query = Rack::Utils.build_query(error: error.message)
+        redirect_to("#{feature_path(params[:feature_name])}?#{query}")
+      rescue InvalidEnrollment
+        bad_request(StandardError.new('invalid enrollment update'))
+      end
+
+      # Delta mode is only the scalar marker "1" plus a real fingerprint.
+      # Any other present marker is rejected so it cannot fall through to a
+      # legacy full-list replacement. Legacy replacement runs only when the
+      # marker is absent, and only for a scalar string.
+      def parse_enrollment!
+        if params.key?(:user_changes)
+          raise InvalidEnrollment unless params[:user_changes] == '1'
+          raise InvalidEnrollment unless params[:feature_version].is_a?(String) && !params[:feature_version].empty?
+          additions = parse_delta_ids(params[:users_to_add])
+          removals = parse_delta_ids(params[:users_to_remove])
+          raise InvalidEnrollment if additions.nil? || removals.nil?
+          return [:delta, additions, removals]
+        end
+
+        return nil unless params.key?(:users)
+
+        users = params[:users]
+        return nil if users.nil?
+        raise InvalidEnrollment unless users.is_a?(String)
+        [:legacy, users]
+      end
+
+      def apply_enrollment!(feature, enrollment)
+        return if enrollment.nil?
+
+        kind, *payload = enrollment
+        if kind == :delta
+          additions, removals = payload
+          current = feature.users.map { |id| id.to_s }.uniq
+          feature.users = (current + additions - removals).uniq.sort
+        else
+          feature.users = payload.fetch(0).split(',').map(&:strip).reject(&:empty?).uniq.sort
+        end
+      end
+
+      def parse_delta_ids(value)
+        return [] if value.nil?
+        return nil unless value.is_a?(String) || value.is_a?(Array)
+        list = value.is_a?(Array) ? value : value.to_s.split(',')
+        return nil unless list.all? { |entry| entry.is_a?(String) }
+        list.map(&:strip).reject(&:empty?)
+      rescue StandardError
+        nil
+      end
+
+      def validate_feature_version!(feature, enrollment = nil)
+        if enrollment&.first == :delta
+          version = params[:feature_version]
+          raise InvalidEnrollment unless version.is_a?(String) && !version.empty?
+          if version != feature_version(feature)
+            raise StaleFeature, STALE_FEATURE_MESSAGE
+          end
+          return
+        end
+
+        stale = if params.key?(:feature_version)
+          params[:feature_version].to_s != feature_version(feature)
+        else
+          feature.data['updated_at'] && params[:last_updated_at].to_s != feature.data['updated_at'].to_s
+        end
+        raise StaleFeature, STALE_FEATURE_MESSAGE if stale
       end
 
       def activate_percentage

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rollout-ui
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - FetLife
@@ -227,13 +227,18 @@ files:
 - lib/rollout/ui.rb
 - lib/rollout/ui/config.rb
 - lib/rollout/ui/helpers.rb
+- lib/rollout/ui/public/css/enrolled-users.css
 - lib/rollout/ui/public/css/tailwind.min.css
+- lib/rollout/ui/public/js/enrolled-users.js
 - lib/rollout/ui/public/js/user-selector.js
 - lib/rollout/ui/version.rb
 - lib/rollout/ui/views/features/index.erb
 - lib/rollout/ui/views/features/new.erb
+- lib/rollout/ui/views/features/partials/enrolled_users.erb
 - lib/rollout/ui/views/features/partials/event_log.erb
+- lib/rollout/ui/views/features/partials/user_pagination.erb
 - lib/rollout/ui/views/features/partials/user_selector.erb
+- lib/rollout/ui/views/features/partials/warning_icon.erb
 - lib/rollout/ui/views/features/show.erb
 - lib/rollout/ui/views/layout.erb
 - lib/rollout/ui/web.rb