openstax_accounts 3.1.1 → 4.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MWU2MDQwOTJlMzhjYzQ5M2FlYmVkYmVmYzUzYzQ1MTZiOWUyMWY3Ng==
+    OWY3YWZhMGEwYzY0NjgyZGNlOTUyOGY0MmNmOWJhOWI3ODJlZDc5NQ==
   data.tar.gz: !binary |-
-    ZjZjMTA3ZGM3YTUyZTUyZTEzZmFkMTg1ZjE0ZTJkZDg3NDUwNGFjOA==
+    MzE3MmRlOTlkNTdiM2FkNmUyYzQzYTI2YzA2NDA3NWU4MDRiZGQ3Nw==
 SHA512:
   metadata.gz: !binary |-
-    MDg0ZjY1ZTM1NDIyYzkyNTY3NzFlMzBhOWQ5YmI1Y2Y4ZjE0ZTRjZWEwYTU1
-    MTY4OTY3N2I3MDgwNDUzZTM4MTZkMDBlMjdiY2U4MTcwMjY1YmNjMjkwNDUx
-    YjY1MjEyZDMxMDkzODkzMjViNWE1N2Q5YmI2N2RlMzYzZDYyZWM=
+    NjYxMmNmZmViMjBlMTU3MjJlOGRlYzA1NGNkNThlMDM1ZmU3ZWVhY2VkMmYx
+    YzBmZGY3Yjg0ZGI5ODI0MmQ5MDg0ZDZlMmI0Njg1NjVjZTk4OGI1ZDk5M2M1
+    Y2Q3MzhhMTU2NGRkZjVmYTM2NTE4ZDM0YzNlNDdjZDBhYjg2ODk=
   data.tar.gz: !binary |-
-    MzVmOGY3NjlkYWM2ZjUzZDY1YmM3NGEzYjY3MTI5N2JkMGE3MWFiNjk4YmI0
-    ODA1ODhkMmY0ZjkxNWU1OTNmYmQwOWMwNjNlOGU2NDdiMzYxNzI4ZDIzODQw
-    MDQ0MzJmOWNkODRiOTRmNTg2OWIzNGFmYjYyYjQ1YjdmYjdkY2Y=
+    ZjM4YTlkMzhmM2IxNGY1NGQ3OTllZjdlMjMwYjE4NWI0ZTQ0NWU3NWUyYjlk
+    YjQ4N2MzMzdjNzQ3MzQ0N2I4Zjg1ZjAxMTI3Nzk1NTk0MjY3YThhOGQ2NDk0
+    NTYxMjY1YmQ1OWM2N2NjOWEyY2ExZDBlMTYyNDk0M2JjOGMxNGQ=

data/app/assets/stylesheets/openstax/accounts/dev.css.scss

@@ -29,3 +29,7 @@
     font-style: italic;
   }
 }
+
+#search-results-list {
+  text-align: center;
+}

data/app/controllers/openstax/accounts/dev/accounts_controller.rb

@@ -12,11 +12,11 @@ module OpenStax
 
         def create
           handle_with(AccountsCreate,
-                      complete: lambda { redirect_back })
+                      complete: lambda { redirect_to dev_accounts_path })
         end
 
         def become
-          @account = Account.find(params[:id])
+          @account = Account.find_by(openstax_uid: params[:id])
           sign_in(@account)
           redirect_back
         end

data/app/handlers/openstax/accounts/accounts_search.rb

@@ -0,0 +1,66 @@
+module OpenStax
+  module Accounts
+    class AccountsSearch
+
+      lev_handler
+
+      paramify :search do
+        attribute :type, type: String
+        attribute :query, type: String
+        attribute :order_by, type: String
+        attribute :page, type: Integer
+        attribute :per_page, type: Integer
+      end
+
+      protected
+
+      def initialize
+        @min_characters = \
+          OpenStax::Accounts.configuration.min_search_characters
+        @max_items = OpenStax::Accounts.configuration.max_search_items
+      end
+
+      def authorized?
+        OSU::AccessPolicy.action_allowed?(:search, caller, Account)
+      end
+
+      def handle
+        case search_params.type
+        when 'Username'
+          query = "username:\"#{search_params.query}\""
+        when 'Name'
+          query = "name:\"#{search_params.query}\""
+        when 'First Name'
+          query = "first_name:\"#{search_params.query}\""
+        when 'Last Name'
+          query = "last_name:\"#{search_params.query}\""
+        when 'Email'
+          query = "email:\"#{search_params.query}\""
+        else
+          query = search_params.query || ''
+        end
+
+        fatal_error(code: :query_too_short,
+                    message: "The provided query is too short (minimum #{
+                      @min_characters} characters).") \
+          if !@min_characters.nil? && query.length < @min_characters
+
+        params = {query: search_params.query,
+                  order_by: search_params.order_by,
+                  page: search_params.page,
+                  per_page: search_params.per_page}
+        out = run(OpenStax::Accounts::SearchAccounts, params).outputs
+        outputs[:total_count] = out[:total_count]
+
+        if !@max_items.nil? && outputs[:total_count] > @max_items
+          fatal_error(code: :too_many_items,
+                      message: "The number of matches exceeded the allowed limit of #{
+                        @max_items} matches. Please refine your query and try again.")
+        end
+
+        outputs[:items] = out[:items].to_a
+      end
+
+    end
+  end
+end

data/app/handlers/openstax/accounts/dev/accounts_search.rb

@@ -1,39 +1,28 @@
 module OpenStax
   module Accounts
     module Dev
-      class AccountsSearch
-
-        lev_handler transaction: :no_transaction
+      class AccountsSearch < OpenStax::Accounts::AccountsSearch
 
         paramify :search do
-          attribute :terms, type: String
           attribute :type, type: String
+          attribute :query, type: String
+          attribute :order_by, type: String
           attribute :page, type: Integer
+          attribute :per_page, type: Integer
         end
 
-        uses_routine OpenStax::Accounts::Dev::SearchAccounts,
-                     as: :search_accounts,
-                     translations: { outputs: {type: :verbatim} }
-
         protected
 
-        def authorized?
-          !Rails.env.production?
+        def initialize
+          @min_characters = nil
+          @max_items = nil
         end
 
-        def handle
-          case search_params.type
-          when 'Name'
-            query = "name:#{search_params.terms.gsub(/\s/,',')}"
-          when 'Username'
-            query = "username:#{search_params.terms.gsub(/\s/,',')}"
-          else
-            query = search_params.terms || ''
-          end
-          run(:search_accounts, query, page: search_params.page || 0)
+        def authorized?
+          !Rails.env.production?
         end
 
       end
     end
   end
-end
+end

data/app/models/openstax/accounts/group.rb

@@ -84,10 +84,12 @@ module OpenStax::Accounts
       return [] unless persisted?
       reload
 
-      gids = [id] + (Group.includes(:member_group_nestings)
-                          .where(member_group_nestings: {member_group_id: openstax_uid})
-                          .first.try(:supertree_group_ids) || [])
-      update_column(:cached_supertree_group_ids, gids.to_yaml)
+      gids = [openstax_uid] + (Group.includes(:member_group_nestings)
+                                    .where(member_group_nestings: {
+                                             member_group_id: openstax_uid
+                                           })
+                                    .first.try(:supertree_group_ids) || [])
+      update_column(:cached_supertree_group_ids, gids)
       self.cached_supertree_group_ids = gids
     end
 
@@ -96,10 +98,12 @@ module OpenStax::Accounts
       return [] unless persisted?
       reload
 
-      gids = [id] + Group.includes(:container_group_nesting)
-                         .where(container_group_nesting: {container_group_id: openstax_uid})
-                         .collect{|g| g.subtree_group_ids}.flatten
-      update_column(:cached_subtree_group_ids, gids.to_yaml)
+      gids = [openstax_uid] + Group.includes(:container_group_nesting)
+                                   .where(container_group_nesting: {
+                                            container_group_id: openstax_uid
+                                          })
+                                   .collect{|g| g.subtree_group_ids}.flatten
+      update_column(:cached_subtree_group_ids, gids)
       self.cached_subtree_group_ids = gids
     end
 

data/app/representers/openstax/accounts/api/v1/account_representer.rb

@@ -1,3 +1,8 @@
+# A representer for Accounts
+#
+# This representer can be used directly or subclassed for an object that delegates
+# openstax_uid, username, first_name, last_name, full_name and title to an account
+
 module OpenStax
   module Accounts
     module Api

data/app/representers/openstax/accounts/api/v1/account_search_representer.rb

@@ -2,26 +2,21 @@ module OpenStax
   module Accounts
     module Api
       module V1
-        class AccountSearchRepresenter < Roar::Decorator
-          include Roar::Representer::JSON
+        class AccountSearchRepresenter < OpenStax::Api::V1::AbstractSearchRepresenter
 
-          property :num_matching_accounts,
-                   as: :num_matching_users,
-                   type: Integer
+          property :total_count,
+                   inherit: true,
+                   schema_info: {
+                     description: "The number of accounts matching the query; can be more than the number returned"
+                   }
 
-          property :page,
-                   type: Integer
-
-          property :per_page,
-                   type: Integer
-
-          property :order_by,
-                   type: String
-
-          collection :accounts,
-                     as: :users,
+          collection :items,
+                     inherit: true,
                      class: Account,
-                     decorator: AccountRepresenter
+                     decorator: Api::V1::AccountRepresenter,
+                     schema_info: {
+                       description: "The accounts matching the query or a subset thereof when paginating"
+                     }
 
         end
       end

data/app/representers/openstax/accounts/api/v1/application_account_search_representer.rb

@@ -8,8 +8,10 @@ module OpenStax
                      as: :application_users,
                      class: OpenStax::Accounts::ApplicationAccount,
                      decorator: ApplicationAccountRepresenter,
+                     writeable: true,
+                     readable: true,
                      schema_info: {
-                       description: "The matching accounts that have used this app",
+                       description: "The accounts of matching users that have used this app",
                        minItems: 0
                      }
 

data/app/routines/openstax/accounts/dev/create_account.rb

@@ -20,7 +20,7 @@ module OpenStax
 
           account = OpenStax::Accounts::Account.new
 
-          account.openstax_uid = -SecureRandom.hex.to_i(16)
+          account.openstax_uid = -SecureRandom.hex(4).to_i(16)/2
           account.access_token = SecureRandom.hex.to_s
           account.username = username
 

data/app/routines/openstax/accounts/search_accounts.rb

@@ -1,191 +1,36 @@
-# Routine for searching for accounts
-#
-# Caller provides a query and some options.  The query follows the rules of
-# https://github.com/bruce/keyword_search , e.g.:
-#
-#   "username:jps,richb" --> returns the "jps" and "richb" accounts
-#   "name:John" --> returns accounts with first, last, or full name
-#                   starting with "John"
-#
-# Query terms can be combined, e.g. "username:jp first_name:john"
-#
-# There are currently two options to control query pagination:
-#
-#   :per_page -- the max number of results to return per page (default: 20)
-#   :page     -- the zero-indexed page to return (default: 0)
-#
-# There is also an option to control the ordering:
-#
-#   :order_by -- comma-separated list of fields to sort by, with an optional
-#                space-separated sort direction (default: "username ASC")
-#
-# Finally, you can also specify a maximum allowed number of results:
-#
-#   :max_matching_accounts -- the max number of results allowed (default: 10)
-#
-# This routine will return an empty relation if the number of results exceeds
-# max_matching_accounts. You can tell that this situation happened when
-# the result has an empty accounts array, but a non-zero num_matching_accounts.
-
 module OpenStax
   module Accounts
     class SearchAccounts
       
       lev_routine transaction: :no_transaction
+
+      uses_routine SearchLocalAccounts,
+                   as: :local_search,
+                   translations: { outputs: { type: :verbatim } }
       
       protected
-      
-      SORTABLE_FIELDS = ['username', 'first_name', 'last_name', 'id']
-      SORT_ASCENDING = 'ASC'
-      SORT_DESCENDING = 'DESC'
 
-      def exec(query, options={})
+      def exec(*args)
+        params = args.last.is_a?(Hash) ? args.pop : {}
+        params[:q] ||= args[0]
+        params[:ob] ||= args[1]
+        params[:pp] ||= args[2]
+        params[:p] ||= args[3]
 
-        if !OpenStax::Accounts.configuration.enable_stubbing? &&\
-           KeywordSearch.search(query).values_at('email', :default).compact.any?
+        query = params[:query] || params[:q]
+        if !OpenStax::Accounts.configuration.enable_stubbing? && \
+           query =~ /email:/
           # Delegate to Accounts
-
           response = OpenStax::Accounts.search_application_accounts(query)
-
-
-          search = OpenStruct.new
-          search_rep = OpenStax::Accounts::Api::V1::AccountSearchRepresenter.new(search)
-          search_rep.from_json(response.body)
-
-          # Need to query local database in order to obtain ID's (primary keys)
-          outputs[:accounts] = OpenStax::Accounts::Account.where {
-            openstax_uid.in search.accounts.collect{ |u| u.openstax_uid }
-          }
-          outputs[:query] = search.q
-          outputs[:per_page] = search.per_page
-          outputs[:page] = search.page
-          outputs[:order_by] = search.order_by
-          outputs[:num_matching_accounts] = search.num_matching_accounts
-
+          OpenStax::Accounts::Api::V1::AccountSearchRepresenter \
+            .new(outputs).from_json(response.body)
         else
-
           # Local search
-          accounts = OpenStax::Accounts::Account.all
-
-          KeywordSearch.search(query) do |with|
-
-            with.default_keyword :any
-
-            with.keyword :username do |usernames|
-              accounts = accounts.where{username
-                .like_any my{prep_names(usernames)}}
-            end
-
-            with.keyword :first_name do |first_names|
-              accounts = accounts.where{lower(first_name)
-                .like_any my{prep_names(first_names)}}
-            end
-
-            with.keyword :last_name do |last_names|
-              accounts = accounts.where{lower(last_name)
-                .like_any my{prep_names(last_names)}}
-            end
-
-            with.keyword :full_name do |full_names|
-              accounts = accounts.where{lower(full_name)
-                .like_any my{prep_names(full_names)}}
-            end
-
-            with.keyword :name do |names|
-              names = prep_names(names)
-              accounts = accounts.where{ (lower(full_name).like_any names)  |
-                                         (lower(last_name).like_any names)  |
-                                         (lower(first_name).like_any names) }
-            end
-
-            with.keyword :id do |ids|
-              accounts = accounts.where{openstax_uid.in ids}
-            end
-
-            with.keyword :email do |emails|
-              accounts = OpenStax::Accounts::Account.none
-            end
-
-            # Rerun the queries above for 'any' terms (which are ones without a
-            # prefix).  
-
-            with.keyword :any do |terms|
-              names = prep_names(terms)
-
-              accounts = accounts.where{
-                (lower(username).like_any   names) |
-                (lower(first_name).like_any names)                     |
-                (lower(last_name).like_any  names)                     |
-                (lower(full_name).like_any  names)                     |
-                (id.in                      terms)
-              }
-            end
-
-          end
-          
-          # Pagination
-          
-          page = options[:page] || 0
-          per_page = options[:per_page] || 20
-          
-          accounts = accounts.limit(per_page).offset(per_page*page)
-          
-          #
-          # Ordering
-          #
-          
-          # Parse the input
-          order_bys = (options[:order_by] || 'username').split(',')
-                        .collect{|ob| ob.strip.split(' ')}
-          
-          # Toss out bad input, provide default direction
-          order_bys = order_bys.collect do |order_by|
-            field, direction = order_by
-            next if !SORTABLE_FIELDS.include?(field)
-            direction ||= SORT_ASCENDING
-            next if direction != SORT_ASCENDING && direction != SORT_DESCENDING
-            [field, direction]
-          end
-          
-          order_bys.compact!
-          
-          # Use a default sort if none provided
-          order_bys = ['username', SORT_ASCENDING] if order_bys.empty?
-          
-          # Convert to query style
-          order_bys = order_bys.collect{|order_by| "#{order_by[0]} #{order_by[1]}"}
-          
-          # Make the ordering call
-          order_bys.each do |order_by|
-            accounts = accounts.order(order_by)
-          end
-          
-          # Translate to routine outputs
-          
-          outputs[:accounts] = accounts
-          outputs[:query] = query
-          outputs[:per_page] = per_page
-          outputs[:page] = page
-          outputs[:order_by] = order_bys.join(', ') # Convert back to String
-          outputs[:num_matching_accounts] = accounts
-            .except(:offset, :limit, :order).count
-
+          run(:local_search, params)
         end
 
-        # Return no results if query exceeds maximum allowed number of matches
-        max_accounts = options[:max_matching_accounts] || \
-                    OpenStax::Accounts.configuration.max_matching_accounts
-        outputs[:accounts] = OpenStax::Accounts::Account.none \
-          if outputs[:num_matching_accounts] > max_accounts
-
-      end
-      
-      # Downcase, remove all wildcards and put a wildcard at the end.
-      def prep_names(names)
-        names.collect{|name| "#{name.downcase.gsub('%', '')}%"}
       end
 
     end
-
   end
 end