identikey 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7250ec019f47150ff6dd6c34436cda2615daad7cc2ab27a9ff24b92a8d412985
-  data.tar.gz: dc079e945e696d1480f80e90ab1ecf339a8b441c243cca201332c199c22ed570
+  metadata.gz: 17806b4e8996eac32014f37f34d9e698b4668e5fd196e1102e2a30c0eb349757
+  data.tar.gz: 26e36da28a662d259e538ef2936d8b03a883c0e38e450a5350e548a336336ed7
 SHA512:
-  metadata.gz: 348dc3966a4bf3e9d31afefc738a0f698572035f2fed833de9f5260d115bd2b528eb546a69599cf67982ed23561691554055b1d998255f69454c681b26f48956
-  data.tar.gz: 8afac75cce4902ce9e3939505c7f1a6707555b7ba1e9906cec0645d136a820fb8f6108c906c76982753499adec8fcd1a9c7a771e1e3861be6c15b7f25f7ec8fa
+  metadata.gz: cf8893d1ae7931194b59c54d0f3a6addd824869c116859ae534f36bb5a6619cebdb1f0e87bb6d8c74c4a67988470053abb2985b6d58e2011d59a0b16eeaf1eeb
+  data.tar.gz: 0c4e3661f8b518f55382490c9af060580d1982f2762904afeef435e9c544e0309e6ced8230bbea0e4b3e23451a544828bd10dc486858d8fc3ca03b792e191437

data/lib/identikey/administration/digipass.rb

@@ -6,6 +6,36 @@ module Identikey
         new(session).find(serial_no)
       end
 
+      def self.search(session:, query:, options: {})
+        query_keys = {
+          'applications'   => 'DIGIPASSFLD_ACTIVE_APPL_NAMES',
+          'app_types'      => 'DIGIPASSFLD_ACTIVE_APPL_TYPES',
+          'status'         => 'DIGIPASSFLD_ASSIGN_STATUS',
+          'user_org_unit'  => 'DIGIPASSFLD_ASSIGNED_USER_ORG_UNIT',
+          'username'       => 'DIGIPASSFLD_ASSIGNED_USERID',
+          'device_id'      => 'DIGIPASSFLD_DEVICE_ID',
+          'direct'         => 'DIGIPASSFLD_DIRECT_ASSIGN_ONLY',
+          'domain'         => 'DIGIPASSFLD_DOMAIN',
+          'type'           => 'DIGIPASSFLD_DPTYPE',
+          'expired'        => 'DIGIPASSFLD_EXPIRED',
+          'grace_expired'  => 'DIGIPASSFLD_GRACE_PERIOD_EXPIRED',
+          'license_serial' => 'DIGIPASSFLD_LICENSE_SERNO',
+          'org_unit'       => 'DIGIPASSFLD_ORGANIZATIONAL_UNIT',
+          'serial'         => 'DIGIPASSFLD_SERNO'
+        }
+
+        stat, digipasses, error = session.execute(:digipass_query,
+          attributes:    Base.search_attributes_from(query, attribute_map: query_keys),
+          query_options: Base.search_options_from(options))
+
+        case stat
+        when 'STAT_SUCCESS'   then (digipasses||[]).map {|user| new(session, user) }
+        when 'STAT_NOT_FOUND' then []
+        else
+          raise Identikey::Error, "Search digipass failed: #{stat} - #{error}"
+        end
+      end
+
       def initialize(session, digipass = nil)
         @session = session
 

data/lib/identikey/administration/session.rb

@@ -85,12 +85,28 @@ module Identikey
         Digipass.find session: self, serial_no: serial_no
       end
 
+      def search_digipasses(query)
+        require_logged_on!
+
+        options = query.delete(:options) || {}
+
+        Digipass.search session: self, query: query, options: options
+      end
+
       def find_user(username, domain = nil)
         require_logged_on!
 
         User.find session: self, username: username, domain: domain || self.domain
       end
 
+      def search_users(query)
+        require_logged_on!
+
+        options = query.delete(:options) || {}
+
+        User.search session: self, query: query, options: options
+      end
+
       def inspect
         "#<#{self.class.name} sid=#@session_id username=#@username domain=#@domain product=#@product>"
       end

data/lib/identikey/administration/user.rb

@@ -6,6 +6,37 @@ module Identikey
         new(session).find(username, domain)
       end
 
+      def self.search(session:, query:, options: {})
+        if query.key?(:has_digipass) && [true, false].include?(query[:has_digipass])
+          query[:has_digipass] = query[:has_digipass] ? 'Assigned' : 'Unassigned'
+        end
+
+        query_keys = {
+          'has_digipass' => 'USERFLD_HAS_DP',
+          'description'  => 'USERFLD_DESCRIPTION',
+          'disabled'     => 'USERFLD_DISABLED',
+          'domain'       => 'USERFLD_DOMAIN',
+          'email'        => 'USERFLD_EMAIL',
+          'expired'      => 'USERFLD_EXPIRED',
+          'locked'       => 'USERFLD_LOCKED',
+          'mobile'       => 'USERFLD_MOBILE',
+          'org_unit'     => 'USERFLD_ORGANIZATIONAL_UNIT',
+          'phone'        => 'USERFLD_PHONE',
+          'username'     => 'USERFLD_USERID',
+        }
+
+        stat, users, error = session.execute(:user_query,
+          attributes:    Base.search_attributes_from(query, attribute_map: query_keys),
+          query_options: Base.search_options_from(options))
+
+        case stat
+        when 'STAT_SUCCESS'   then (users||[]).map {|user| new(session, user) }
+        when 'STAT_NOT_FOUND' then []
+        else
+          raise Identikey::Error, "Search user failed: #{stat} - #{error}"
+        end
+      end
+
       attr_accessor :username
       attr_accessor :email
       attr_accessor :mobile
@@ -25,6 +56,7 @@ module Identikey
       attr_accessor :expires_at
       attr_accessor :expired
       attr_accessor :last_auth_attempt_at
+      attr_accessor :description
 
       def initialize(session, user = nil)
         @session = session
@@ -116,6 +148,7 @@ module Identikey
           self.expires_at           = user['USERFLD_EXPIRATION_TIME']
           self.expired              = user['USERFLD_EXPIRED']
           self.last_auth_attempt_at = user['USERFLD_LASTAUTHREQ_TIME']
+          self.description          = user['USERFLD_DESCRIPTION']
 
           @persisted = persisted
 

data/lib/identikey/administration.rb

@@ -15,8 +15,8 @@ module Identikey
     client wsdl: './sdk/wsdl/administration.wsdl'
 
     operations :logon, :logoff, :sessionalive,
-      :admin_session_query, :user_execute,
-      :digipass_execute, :digipassappl_execute
+      :admin_session_query, :user_execute, :user_query,
+      :digipass_execute, :digipass_query, :digipassappl_execute
 
     def logon(username:, password:, domain:)
       resp = super(message: {
@@ -150,6 +150,20 @@ module Identikey
       )
     end
 
+
+    def user_query(session_id:, attributes:, query_options:)
+      resp = super(message: {
+        sessionID: session_id,
+        attributeSet: {
+          attributes: typed_attributes_query_list_from(attributes)
+        },
+        queryOptions: query_options
+      })
+
+      parse_response resp, :user_query_response
+    end
+
+
     def digipass_execute(session_id:, cmd:, attributes: [])
       resp = super(message: {
         sessionID: session_id,
@@ -195,6 +209,20 @@ module Identikey
       )
     end
 
+
+    def digipass_query(session_id:, attributes:, query_options:)
+      resp = super(message: {
+        sessionID: session_id,
+        attributeSet: {
+          attributes: typed_attributes_query_list_from(attributes)
+        },
+        queryOptions: query_options
+      })
+
+      parse_response resp, :digipass_query_response
+    end
+
+
     def digipassappl_execute(session_id:, cmd:, attributes:)
       resp = super(message: {
         sessionID: session_id,

data/lib/identikey/base.rb

@@ -220,12 +220,35 @@ module Identikey
         end
       end
 
+      def typed_attributes_list_from(hash)
+        self.class.typed_attributes_list_from(hash)
+      end
+
+      # Calls typed_attribute_query_list_from() by removing the
+      # nil values from the given hash.
+      #
+      # The nil values are ignored when calling API endpoints that
+      # are not query ones, as such there is no point in adding an
+      # attributeOption null:true on those.
+      #
+      def self.typed_attributes_list_from(hash)
+        typed_attributes_query_list_from(hash.reject {|k,v| v.nil?})
+      end
+
+      def typed_attributes_query_list_from(hash)
+        self.class.typed_attributes_query_list_from(hash)
+      end
+
       # Converts and hash keyed by attribute name into an array of hashes
       # whose keys are the attribute name as attributeID and the value as
       # a Gyoku-compatible hash with the xsd:type annotation. The type is
       # inferred from the Ruby value type and the contents are serialized
       # as a string formatted as per the XSD DTD definition.
       #
+      # Further, this supports "virtual" attributes with a "NOT_" prefix.
+      # If the NOT_ prefix is set to the attribute name then the negative
+      # attributeOption is set.
+      #
       # <rant>
       # This code should not exist, because defining argument types is what
       # WSDL is for.  However, in the braindead web services implementation
@@ -235,8 +258,15 @@ module Identikey
       # than an aid.
       # </rant>
       #
-      def typed_attributes_list_from(hash)
-        hash.map do |name, value|
+      def self.typed_attributes_query_list_from(hash)
+        hash.map do |full_name, value|
+
+          parse = /^(not_)?(.*)/i.match(full_name.to_s)
+          name  = parse[2]
+
+          options = []
+          options.push(negative: true) if !parse[1].nil?
+
           type, value = case value
 
           when Unsigned
@@ -255,17 +285,61 @@ module Identikey
             [ 'xsd:string', value.to_s ]
 
           when NilClass
-            next
+            options.push(null: true)
+            [ 'xsd:string', '' ]
 
           else
-            raise Identikey::UsageError, "#{name} type #{value.class} is unsupported"
+            raise Identikey::UsageError, "#{full_name} type #{value.class} is unsupported"
           end
 
-          { attributeID: name.to_s,
+          { attributeID:      name,
+            attributeOptions: options,
             value: { '@xsi:type': type, content!: value } }
         end.compact
       end
 
+      # Translates the given attributes map into an hash suitable to be passed
+      # to typed_attributes_query_list_from(). This is used only to DRY the
+      # invocations across the _query methods.
+      #
+      def self.search_attributes_from(query, attribute_map:)
+        query.inject({}) do |ret, (key, value)|
+
+          parse  = /^(not_)?(.*)/.match(key.to_s)
+          negate = !parse[1].nil?
+          name   =  parse[2]
+
+          attribute = attribute_map.fetch(name, nil)
+
+          if attribute.nil?
+            raise Identikey::UsageError, "Invalid search key: #{key}"
+          end
+
+          attribute = "NOT_#{attribute}" if negate
+
+          ret.update(attribute => value)
+        end
+      end
+
+      # Translate our search interface options into Identikey's _query methods
+      # interface options.
+      #
+      def self.search_options_from(options)
+        options.inject({}) do |ret, (option, value)|
+          attribute = {
+            'distinct' => 'distinct',
+            'limit'    => 'rowcount',
+            'offset'   => 'rowoffset',
+          }.fetch(option.to_s, nil)
+
+          if attribute.nil?
+            raise Identikey::UsageError, "Invalid search option: #{option}"
+          end
+
+          ret.update(attribute => value)
+        end
+      end
+
     # protected
 
   end

data/lib/identikey/version.rb

@@ -1,3 +1,3 @@
 module Identikey
-  VERSION = "0.4.3"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: identikey
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Marcello Barnaba
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-24 00:00:00.000000000 Z
+date: 2019-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: savon