Merge pull request #1 from ike/logon

Logon, Logoff, and GetUserProfile

Merge pull request #1 from ike/logon
Logon, Logoff, and GetUserProfile
Isaac Lewis · GitHub
2 parents db76748d 697a8854
Showing 15 changed files with 280 additions and 113 deletions Show diff stats
lib/syspro.rb
lib/syspro/api_operations/request.rb
lib/syspro/api_resource.rb
lib/syspro/get_logon_profile.rb
lib/syspro/api_operations/get_version.rb → lib/syspro/get_version.rb
lib/syspro/logoff.rb
lib/syspro/logon.rb
lib/syspro/singleton_api_resource.rb
lib/syspro/syspro_client.rb
lib/syspro/syspro_object.rb
lib/syspro/syspro_response.rb
lib/syspro/util.rb
test/client_test.rb
test/logoff_test.rb
test/logon_test.rb
@@ -5,6 +5,10 @@ require &quot;logger&quot;
 require "openssl"
 require "syspro/api_resource"
+require "syspro/get_logon_profile"
+require "syspro/get_version"
+require "syspro/logoff"
+require "syspro/logon"
 require "syspro/syspro_client"
 require "syspro/singleton_api_resource"
 require "syspro/syspro_object"
@@ -12,10 +16,8 @@ require &quot;syspro/syspro_response&quot;
 require "syspro/util"
 require "syspro/version"
-require "syspro/api_operations/get_version"
 require "syspro/api_operations/request"
-
 module Syspro
   @api_base = "http://syspro.wildlandlabs.com:90/SYSPROWCFService/Rest"
 module Syspro
   module ApiOperations
     module Request
-      def request(method, url, params = {}, opts = {})
-          client = SysproClient.active_client
+      module ClassMethods
+        def request(method, url, params = {}, opts = {})
+          warn_on_opts_in_params(params)
+
+          opts = Util.normalize_opts(opts)
+          opts[:client] ||= SysproClient.active_client
           headers = opts.clone
+          user_id = headers.delete(:user_id)
+          client = headers.delete(:client)
+          # Assume all remaining opts must be headers
           resp = client.execute_request(
             method, url,
             headers: headers,
+            user_id: user_id,
             params: params
           )
           resp
-      end
+        end
-      def warn_on_opts_in_params(params)
+        private
+
+        def warn_on_opts_in_params(params)
           Util::OPTS_USER_SPECIFIED.each do |opt|
             if params.key?(opt)
               $stderr.puts("WARNING: #{opt} should be in opts instead of params.")
             end
           end
+        end
+      end # ClassMethods
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      protected
+
+      def request(method, url, params = {}, opts = {})
+        opts = @opts.merge(Util.normalize_opts(opts))
+        self.class.request(method, url, params, opts)
       end
     end
   end
-require_relative "syspro_client"
-require_relative "api_operations/request"
+require "syspro/syspro_object"
+require "syspro/api_operations/request"
 module Syspro
-  class ApiResource < Syspro::SysproClient
+  class ApiResource < SysproObject
+    include Syspro::ApiOperations::Request
     def self.class_name
       name.split("::")[-1]
     end
     def self.resource_url
-      if self == APIResource
+      if self == ApiResource
         raise NotImplementedError, "APIResource is an abstract class.  You should perform actions on its subclasses (Charge, Customer, etc.)"
       end
-      "/v1/#{CGI.escape(class_name.downcase)}s"
+      "/#{CGI.escape(class_name.downcase)}"
     end
     def resource_url
-      unless (id = self["id"])
-        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", "id")
-      end
-      "#{self.class.resource_url}/#{CGI.escape(id)}"
+      #unless (id = self["id"])
+        #raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", "id")
+      #end
+      #"#{self.class.resource_url}/#{CGI.escape(id)}"
     end
     def refresh
+module Syspro
+  class GetLogonProfile < ApiResource
+    def self.get_logon_profile(user_id)
+      params = { "UserId" => user_id }
+      resp = self.request(:get, resource_url, params)
+      parse_response(resp[0])
+    end
+
+    def resource_url
+      "/GetLogonProfile"
+    end
+
+    def self.parse_response(resp)
+      doc = resp.data
+
+      UserProfile.new(
+        doc.xpath("//CompanyName").text,
+        doc.xpath("//OperatorCode").text,
+        doc.xpath("//OperatorGroup").text,
+        doc.xpath("//OperatorEmailAddress").text,
+        doc.xpath("//OperatorLocation").text,
+        doc.xpath("//OperatorLanguageCode").text,
+        doc.xpath("//SystemLanguage").text,
+        doc.xpath("//AccountingDate").text,
+        doc.xpath("//CompanyDate").text,
+        doc.xpath("//DefaultArBranch").text,
+        doc.xpath("//DefaultApBranch").text,
+        doc.xpath("//DefaultBank").text,
+        doc.xpath("//DefaultWarehouse").text,
+        doc.xpath("//DefaultCustomer").text,
+        doc.xpath("//SystemSiteId").text,
+        doc.xpath("//SystemNationalityCode").text,
+        doc.xpath("//LocalCurrencyCode").text,
+        doc.xpath("//CurrencyDescription").text,
+        doc.xpath("//DefaultRequisitionUser").text,
+        doc.xpath("//XMLToHTMLTransform").text,
+        doc.xpath("//CssStyle").text,
+        doc.xpath("//CssSuffix").text,
+        doc.xpath("//DecimalFormat").text,
+        doc.xpath("//DateFormat").text,
+        doc.xpath("//FunctionalRole").text,
+        doc.xpath("//DatabaseType").text,
+        doc.xpath("//SysproVersion").text,
+        doc.xpath("//EnetVersion").text,
+        doc.xpath("//SysproServerBitWidth").text,
+      )
+    end
+    private_class_method :parse_response
+
+    UserProfile = Struct.new(:company_name, :operator_code, :operator_group, :operator_email_address,
+                             :operator_location, :operator_language_code, :system_language, :accounting_date,
+                             :company_date, :default_ar_branch, :default_ap_branch, :default_bank, :default_warehouse,
+                             :default_customer, :system_site_id, :system_nationality_code, :local_currency_code,
+                             :currency_description, :default_requisition_user, :xml_to_html_transform, :css_style,
+                             :css_suffix, :decimal_format, :date_format, :functional_role, :database_type, :syspro_version,
+                             :enet_version, :syspro_server_bit_width)
+  end
+end
+
-require_relative "request"
-
 module Syspro
-  module ApiOperations
-    class GetVersion
-      include ApiOperations::Request
+  class GetVersion < ApiResource
+    def self.get_version
+      resp = self.request(:get, resource_url)
+      VersionObject.new(resp[0].http_body)
+    end
-      def resource_url
-        "/GetVersion"
-      end
+    def resource_url
+      "/GetVersion"
     end
+
+    VersionObject = Struct.new(:version)
   end
 end
+module Syspro
+  class Logoff < ApiResource
+    def self.logoff(user_id)
+      params = { "UserId" => user_id }
+      resp = self.request(:get, resource_url, params)
+
+      if resp[0].http_body == "0"
+        true
+      else
+        resp[0].http_body
+      end
+    end
+
+    def resource_url
+      "/Logoff"
+    end
+  end
+end
+module Syspro
+  class Logon < ApiResource
+    def self.logon(username, password, company_id, company_password = nil)
+      params = {
+        "Operator" => username,
+        "OperatorPassword" => password,
+        "CompanyId" => company_id,
+        "CompanyPassword" => company_password
+      }
+      resp = self.request(:get, resource_url, params)
+      UserIdObject.new(resp[0].http_body)
+    end
+
+    def resource_url
+      "/Logon"
+    end
+
+    UserIdObject = Struct.new(:guid)
+  end
+end
+
@@ -6,7 +6,7 @@ module Syspro
       if self == SingletonAPIResource
         raise NotImplementedError, "SingletonAPIResource is an abstract class.  You should perform actions on its subclasses (Customer, etc.)"
       end
-      "/v1/#{CGI.escape(class_name.downcase)}"
+      "/#{CGI.escape(class_name.downcase)}"
     end
     def resource_url
@@ -2,11 +2,21 @@ module Syspro
   class SysproClient
     attr_accessor :conn, :api_base
+    @verify_ssl_warned = false
+
     def initialize(conn = nil)
       self.conn = conn || self.class.default_conn
       @system_profiler = SystemProfiler.new
     end
+    def logon(username, password, company_id, company_password)
+      Syspro::Logon.logon(username, password, company_id, company_password)
+    end
+
+    def get_syspro_version
+      Syspro::GetVersion.get_version
+    end
+
     def self.active_client
       Thread.current[:syspro_client] || default_client
     end
@@ -15,11 +25,6 @@ module Syspro
       Thread.current[:syspro_client_default_client] ||= SysproClient.new(default_conn)
     end
-    def get_syspro_version
-      version_getter = Syspro::ApiOperations::GetVersion.new
-      version_getter.request(:get, version_getter.resource_url)
-    end
-
     # A default Faraday connection to be used when one isn't configured. This
     # object should never be mutated, and instead instantiating your own
     # connection and wrapping it in a SysproClient object should be preferred.
@@ -53,8 +58,27 @@ module Syspro
       end
     end
-    def execute_request(method, path, api_base: nil, headers: {}, params: {})
+    # Executes the API call within the given block. Usage looks like:
+    #
+    #     client = StripeClient.new
+    #     charge, resp = client.request { Charge.create }
+    #
+    def request
+      @last_response = nil
+      old_stripe_client = Thread.current[:stripe_client]
+      Thread.current[:stripe_client] = self
+
+      begin
+        res = yield
+        [res, @last_response]
+      ensure
+        Thread.current[:stripe_client] = old_stripe_client
+      end
+    end
+
+    def execute_request(method, path, user_id: nil, api_base: nil, headers: {}, params: {})
       api_base ||= Syspro.api_base
+      user_id  ||= ""
       params = Util.objects_to_ids(params)
       url = api_url(path, api_base)
@@ -82,6 +106,7 @@ module Syspro
       context.body            = body
       context.method          = method
       context.path            = path
+      context.user_id         = user_id
       context.query_params    = query_params ? Util.encode_parameters(query_params) : nil
       http_resp = execute_request_with_rescues(api_base, context) do
@@ -238,6 +263,7 @@ module Syspro
       attr_accessor :path
       attr_accessor :query_params
       attr_accessor :request_id
+      attr_accessor :user_id
       # The idea with this method is that we might want to update some of
       # context information because a response that we've received from the API
 module Syspro
   class SysproObject
+    include Enumerable
-    # Re-initializes the object based on a hash of values (usually one that's
-    # come back from an API call). Adds or removes value accessors as necessary
-    # and updates the state of internal data.
-    #
-    # Protected on purpose! Please do not expose.
-    #
-    # ==== Options
-    #
-    # * +:values:+ Hash used to update accessors and values.
-    # * +:opts:+ Options for SysproObject like an API key.
-    # * +:partial:+ Indicates that the re-initialization should not attempt to
-    #   remove accessors.
-    def initialize_from(values, opts, partial = false)
+    def initialize(id = nil, opts = {})
       @opts = Util.normalize_opts(opts)
+    end
-      # the `#send` is here so that we can keep this method private
-      @original_values = self.class.send(:deep_copy, values)
-
-      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
-      added = Set.new(values.keys - @values.keys)
-
-      # Wipe old state before setting new.  This is useful for e.g. updating a
-      # customer, where there is no persistent card parameter.  Mark those values
-      # which don't persist as transient
-
-      remove_accessors(removed)
-      add_accessors(added, values)
+    # Determines the equality of two Syspro objects. Syspro objects are
+    # considered to be equal if they have the same set of values and each one
+    # of those values is the same.
+    def ==(other)
+      other.is_a?(SysproObject) && @values == other.instance_variable_get(:@values)
+    end
-      removed.each do |k|
-        @values.delete(k)
-        @transient_values.add(k)
-        @unsaved_values.delete(k)
-      end
+    def to_s(*_args)
+      JSON.pretty_generate(to_hash)
+    end
-      update_attributes(values, opts, dirty: false)
-      values.each_key do |k|
-        @transient_values.delete(k)
-        @unsaved_values.delete(k)
-      end
+    def inspect
+      id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ""
+      "#<#{self.class}:0x#{object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
+    end
-      self
+    def keys
+      @values.keys
     end
-    def remove_accessors(keys)
-      # not available in the #instance_eval below
-      protected_fields = self.class.protected_fields
+    def values
+      @values.values
+    end
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if protected_fields.include?(k)
-          next if @@permanent_attributes.include?(k)
+    def to_hash
+      maybe_to_hash = lambda do |value|
+        value && value.respond_to?(:to_hash) ? value.to_hash : value
+      end
-          # Remove methods for the accessor's reader and writer.
-          [k, :"#{k}=", :"#{k}?"].each do |method_name|
-            remove_method(method_name) if method_defined?(method_name)
-          end
-        end
+      @values.each_with_object({}) do |(key, value), acc|
+        acc[key] = case value
+                   when Array
+                     value.map(&maybe_to_hash)
+                   else
+                     maybe_to_hash.call(value)
+                   end
       end
     end
-    def add_accessors(keys, values)
-      # not available in the #instance_eval below
-      protected_fields = self.class.protected_fields
-
-      metaclass.instance_eval do
-        keys.each do |k|
-          next if protected_fields.include?(k)
-          next if @@permanent_attributes.include?(k)
-
-          if k == :method
-            # Object#method is a built-in Ruby method that accepts a symbol
-            # and returns the corresponding Method object. Because the API may
-            # also use `method` as a field name, we check the arity of *args
-            # to decide whether to act as a getter or call the parent method.
-            define_method(k) { |*args| args.empty? ? @values[k] : super(*args) }
-          else
-            define_method(k) { @values[k] }
-          end
-
-          define_method(:"#{k}=") do |v|
-            if v == ""
-              raise ArgumentError, "You cannot set #{k} to an empty string. " \
-                "We interpret empty strings as nil in requests. " \
-                "You may set (object).#{k} = nil to delete the property."
-            end
-            @values[k] = Util.convert_to_stripe_object(v, @opts)
-            dirty_value!(@values[k])
-            @unsaved_values.add(k)
-          end
+    def each(&blk)
+      @values.each(&blk)
+    end
-          if [FalseClass, TrueClass].include?(values[k].class)
-            define_method(:"#{k}?") { @values[k] }
-          end
+    private
+
+    # Produces a deep copy of the given object including support for arrays,
+    # hashes, and SysproObject.
+    def self.deep_copy(obj)
+      case obj
+      when Array
+        obj.map { |e| deep_copy(e) }
+      when Hash
+        obj.each_with_object({}) do |(k, v), copy|
+          copy[k] = deep_copy(v)
+          copy
         end
+      when SysproObject
+        obj.class.construct_from(
+          deep_copy(obj.instance_variable_get(:@values)),
+          obj.instance_variable_get(:@opts).select do |k, _v|
+            Util::OPTS_COPYABLE.include?(k)
+          end
+        )
+      else
+        obj
       end
     end
+    private_class_method :deep_copy
+
   end
 end
@@ -26,8 +26,8 @@ module Syspro
     # This may throw JSON::ParserError if the response body is not valid JSON.
     def self.from_faraday_hash(http_resp)
       resp = SysproResponse.new
-      resp.data = Nokogiri::XML(http_resp[:body])
       resp.http_body = http_resp[:body]
+      resp.data = Nokogiri::XML(resp.http_body)
       resp.http_headers = http_resp[:headers]
       resp.http_status = http_resp[:status]
       resp.request_id = http_resp[:headers]["Request-Id"]
@@ -39,8 +39,8 @@ module Syspro
     # This may throw JSON::ParserError if the response body is not valid JSON.
     def self.from_faraday_response(http_resp)
       resp = SysproResponse.new
-      resp.data = Nokogiri::XML(http_resp[:body])
       resp.http_body = http_resp.body
+      resp.data = Nokogiri::XML(resp.http_body)
       resp.http_headers = http_resp.headers
       resp.http_status = http_resp.status
       resp.request_id = http_resp.headers["Request-Id"]
@@ -125,6 +125,13 @@ module Syspro
       end
     end
+    def self.url_encode(key)
+      CGI.escape(key.to_s).
+        # Don't use strict form encoding by changing the square bracket control
+        # characters back to their literals. This is fine by the server, and
+        # makes these parameter strings easier to read.
+        gsub("%5B", "[").gsub("%5D", "]")
+    end
   end
 end
@@ -3,6 +3,6 @@ require &quot;test_helper&quot;
 class SysproClientTest < Minitest::Test
   def test_get_syspro_version
     client = ::Syspro::SysproClient.new
-    assert_match /(\d+\.)?(\d+\.)?(\d+\.)?(\d+)/, client.get_syspro_version[0].http_body
+    assert_match (/(\d+\.)?(\d+\.)?(\d+\.)?(\d+)/), client.get_syspro_version.version
   end
 end
+require "test_helper"
+
+class LogoffTest < Minitest::Test
+  def test_successful_logoff
+    username = "wland"
+    password = "piperita2016"
+    company  = "L"
+    company_password = ""
+
+    uid = Syspro::Logon.logon(username, password, company, company_password)
+    assert_equal true, Syspro::Logoff.logoff(uid.guid)
+  end
+
+  def test_logoff_error
+    assert_kind_of String, Syspro::Logoff.logoff('1BB5B3050954BB459A5D034DB5CC386980')
+  end
+end
+
+require "test_helper"
+
+class LogonTest < Minitest::Test
+  def test_logon
+    username = "wland"
+    password = "piperita2016"
+    company  = "L"
+    company_password = ""
+    client = ::Syspro::SysproClient.new
+
+    assert_match (/([A-Z0-9]{33})\w/), client.logon(username, password, company, company_password).guid
+  end
+end
+