qbwc 0.0.5 → 0.1.0

data/lib/qbwc/controller.rb

@@ -0,0 +1,176 @@
+require 'wash_out/version'
+include WashOut
+
+module QBWC
+  module Controller
+
+    AUTHENTICATE_NOT_VALID_USER = 'nvu'
+    AUTHENTICATE_NO_WORK = 'none'
+
+    def self.included(base)
+      base.class_eval do
+        include WashOut::SOAP
+        skip_before_filter :_parse_soap_parameters, :_authenticate_wsse, :_map_soap_parameters, :only => :qwc
+        before_filter :get_session, :except => [:qwc, :authenticate, :_generate_wsdl]
+        after_filter :save_session, :except => [:qwc, :authenticate, :_generate_wsdl, :close_connection, :connection_error]
+
+        # wash_out changed the format of app/views/wash_with_soap/rpc/response.builder in commit
+        # https://github.com/inossidabile/wash_out/commit/24a77f4a3d874562732c6e8c3a30e8defafea7cb
+        wash_out_xml_namespace = (Gem::Version.new(WashOut::VERSION) < Gem::Version.new('0.9.1') ? 'tns:' : '')
+
+        soap_action 'serverVersion', :to => :server_version,
+                    :return => {'tns:serverVersionResult' => :string},
+                    :response_tag => "#{wash_out_xml_namespace}serverVersionResponse"
+
+        soap_action 'clientVersion', :to => :client_version,
+                    :args   => {:strVersion => :string},
+                    :return => {'tns:clientVersionResult' => :string},
+                    :response_tag => "#{wash_out_xml_namespace}clientVersionResponse"
+
+        soap_action 'authenticate',
+                    :args   => {:strUserName => :string, :strPassword => :string},
+                    :return => {'tns:authenticateResult' => StringArray},
+                    :response_tag => "#{wash_out_xml_namespace}authenticateResponse"
+
+        soap_action 'sendRequestXML', :to => :send_request,
+                    :args   => {:ticket => :string, :strHCPResponse => :string, :strCompanyFilename => :string, :qbXMLCountry => :string, :qbXMLMajorVers => :string, :qbXMLMinorVers => :string},
+                    :return => {'tns:sendRequestXMLResult' => :string},
+                    :response_tag => "#{wash_out_xml_namespace}sendRequestXMLResponse"
+
+        soap_action 'receiveResponseXML', :to => :receive_response,
+                    :args   => {:ticket => :string, :response => :string, :hresult => :string, :message => :string},
+                    :return => {'tns:receiveResponseXMLResult' => :integer},
+                    :response_tag => "#{wash_out_xml_namespace}receiveResponseXMLResponse"
+
+        soap_action 'closeConnection', :to => :close_connection,
+                    :args   => {:ticket => :string},
+                    :return => {'tns:closeConnectionResult' => :string},
+                    :response_tag => "#{wash_out_xml_namespace}closeConnectionResponse"
+
+        soap_action 'connectionError', :to => :connection_error,
+                    :args   => {:ticket => :string, :hresult => :string, :message => :string},
+                    :return => {'tns:connectionErrorResult' => :string},
+                    :response_tag => "#{wash_out_xml_namespace}connectionErrorResponse"
+
+        soap_action 'getLastError', :to => :get_last_error,
+                    :args   => {:ticket => :string},
+                    :return => {'tns:getLastErrorResult' => :string},
+                    :response_tag => "#{wash_out_xml_namespace}getLastErrorResponse"
+      end
+    end
+
+    def qwc
+      # Optional tag
+      scheduler_block = ''
+      if !QBWC.minutes_to_run.nil?
+        scheduler_block = <<SB
+   <Scheduler>
+      <RunEveryNMinutes>#{QBWC.minutes_to_run}</RunEveryNMinutes>
+   </Scheduler>
+SB
+      end
+
+      qwc = <<QWC
+<QBWCXML>
+   <AppName>#{Rails.application.class.parent_name} #{Rails.env} #{@app_name_suffix}</AppName>
+   <AppID></AppID>
+   <AppURL>#{qbwc_action_url(:only_path => false)}</AppURL>
+   <AppDescription>Quickbooks integration</AppDescription>
+   <AppSupport>#{QBWC.support_site_url || root_url(:protocol => 'https://')}</AppSupport>
+   <UserName>#{@username || QBWC.username}</UserName>
+   <OwnerID>#{QBWC.owner_id}</OwnerID>
+   <FileID>{90A44FB5-33D9-4815-AC85-BC87A7E7D1EB}</FileID>
+   <QBType>QBFS</QBType>
+   <Style>Document</Style>
+   #{scheduler_block}
+</QBWCXML>
+QWC
+      send_data qwc, :filename => "#{@filename || Rails.application.class.parent_name}.qwc", :content_type => 'application/x-qwc'
+    end
+
+    class StringArray < WashOut::Type
+      map "tns:string" => [:string]
+    end
+
+    def server_version
+      render :soap => {"tns:serverVersionResult" => server_version_response}
+    end
+
+    def client_version
+      render :soap => {"tns:clientVersionResult" => check_client_version}
+    end
+
+    def authenticate
+      username = params[:strUserName]
+      password = params[:strPassword]
+      if !QBWC.authenticator.nil?
+        company_file_path = QBWC.authenticator.call(username, password)
+      elsif username == QBWC.username && password == QBWC.password
+        company_file_path = QBWC.company_file_path
+      else
+        company_file_path = nil
+      end
+
+      ticket = nil
+      if company_file_path.nil?
+        QBWC.logger.info "Authentication of user '#{username}' failed."
+        company_file_path = AUTHENTICATE_NOT_VALID_USER
+      elsif !QBWC.pending_jobs(company_file_path).present?
+        QBWC.logger.info "Authentication of user '#{username}' succeeded, but no jobs pending for '#{company_file_path}'."
+        company_file_path = AUTHENTICATE_NO_WORK
+      else
+        QBWC.logger.info "Authentication of user '#{username}' succeeded, jobs are pending for '#{company_file_path}'."
+        ticket = QBWC.storage_module::Session.new(username, company_file_path).ticket
+        QBWC.session_initializer.call(get_session(ticket)) unless QBWC.session_initializer.nil?
+      end
+      render :soap => {"tns:authenticateResult" => {"tns:string" => [ticket || '', company_file_path]}}
+    end
+
+    def send_request
+      request = @session.request_to_send
+      render :soap => {'tns:sendRequestXMLResult' => request}
+    end
+
+    def receive_response
+      if params[:hresult]
+        QBWC.logger.warn "#{params[:hresult]}: #{params[:message]}"
+        @session.error = params[:message]
+        @session.status_code = params[:hresult]
+        @session.status_severity = 'Error'
+      end
+      @session.response = params[:response]
+      render :soap => {'tns:receiveResponseXMLResult' => (QBWC::on_error == 'continueOnError' || @session.error.nil?) ? @session.progress : -1}
+    end
+
+    def close_connection
+      @session.destroy
+      render :soap => {'tns:closeConnectionResult' => 'OK'}
+    end
+
+    def connection_error
+      @session.destroy
+      logger.warn "#{params[:hresult]}: #{params[:message]}"
+      render :soap => {'tns:connectionErrorResult' => 'done'}
+    end
+
+    def get_last_error
+      render :soap => {'tns:getLastErrorResult' => @session.error || ''}
+    end
+
+    protected
+
+    def get_session(ticket = params[:ticket])
+      @session = QBWC.storage_module::Session.get(ticket)
+    end
+
+    def save_session
+      @session.save if @session
+    end
+
+    def server_version_response
+    end
+
+    def check_client_version
+    end
+  end
+end

data/lib/qbwc/job.rb

@@ -1,47 +1,110 @@
 class QBWC::Job
 
-  attr_reader :name, :response_proc, :requests
+  attr_reader :name, :company, :worker_class
 
-  def initialize(name, &block)
+  def initialize(name, enabled, company, worker_class, requests = [], data = nil)
     @name = name
-    @enabled = true
-    @requests = block
+    @enabled = enabled
+    @company = company || QBWC.company_file_path
+    @worker_class = worker_class
+    @requests = requests
+    @data = data
+    @request_index = 0
+  end
+
+  def worker
+    worker_class.constantize.new
+  end
 
-    reset
+  def process_response(qbxml_response, response, session, advance)
+    QBWC.logger.info "Processing response."
+    completed_request = requests[request_index]
+    advance_next_request if advance
+    QBWC.logger.info "Job '#{name}' received response: '#{qbxml_response}'." if QBWC.log_requests_and_responses
+    worker.handle_response(response, session, self, completed_request, data)
   end
 
-  def set_response_proc(&block) 
-    @response_proc = block
+  def advance_next_request
+    new_index = request_index + 1
+    QBWC.logger.info "Job '#{name}' advancing to request #'#{new_index}'."
+    self.request_index = new_index
   end
 
   def enable
-    @enabled = true
+    self.enabled = true
   end
 
   def disable
-    @enabled = false
+    self.enabled = false
+  end
+
+  def pending?
+    if !enabled?
+      QBWC.logger.info "Job '#{name}' not enabled."
+      return false
+    end
+    sr = worker.should_run?(self)
+    QBWC.logger.info "Job '#{name}' should_run?: #{sr}."
+    return sr
   end
 
   def enabled?
     @enabled
   end
 
-  def next
-    @request_gen.alive? ? @request_gen.resume : nil
+  def requests
+    @requests
   end
 
-  def reset
-    @request_gen = new_request_generator
+  def requests=(r)
+    @requests = r
   end
 
-private
+  def data
+    @data
+  end
 
-  def new_request_generator
-    Fiber.new { request_queue.each { |r| Fiber.yield r }; nil }
+  def data=(d)
+    @data = d
   end
 
-  def request_queue
-    QBWC::Request.from_array(@requests.call, @response_proc )
+  def request_index
+    @request_index
+  end
+
+  def request_index=(ri)
+    @request_index = ri
+  end
+
+  def requests_provided_when_job_added
+    @requests_provided_when_job_added
+  end
+
+  def requests_provided_when_job_added=(value)
+    @requests_provided_when_job_added = value
+  end
+
+  def next_request
+    # Generate and save the requests to run when starting the job.
+    if (requests.nil? || requests.empty?) && ! self.requests_provided_when_job_added
+      r = worker.requests(self)
+      r = [r] unless r.nil? || r.is_a?(Array)
+      self.requests = r
+    end
+
+    QBWC.logger.info("Requests available are '#{requests}'.") if QBWC.log_requests_and_responses
+    ri = request_index
+    QBWC.logger.info("Request index is '#{ri}'.")
+    return nil if ri.nil? || requests.nil? || ri >= requests.length
+    nr = requests[ri]
+    QBWC.logger.info("Next request is '#{nr}'.") if QBWC.log_requests_and_responses
+    return QBWC::Request.new(nr)
+  end
+  alias :next :next_request  # Deprecated method name 'next'
+
+  def reset
+    self.request_index = 0
+    self.requests = [] unless self.requests_provided_when_job_added
   end
 
 end

data/lib/qbwc/railtie.rb

@@ -0,0 +1,8 @@
+require 'wash_out'
+
+module QBWC
+  class Railtie < ::Rails::Railtie
+    config.wash_out.parser = :nokogiri
+    config.wash_out.namespace = 'http://developer.intuit.com/'
+  end
+end

data/lib/qbwc/request.rb

@@ -1,46 +1,37 @@
 class QBWC::Request
 
   attr_reader   :request, :response_proc
-  attr_accessor :response, :error
 
-  def initialize(request, response_proc)
+  def initialize(request)
     #Handle Cases for a request passed in as a Hash or String
     #If it's a hash verify that it is properly wrapped with qbxml_msg_rq and xml_attributes for on_error events
     #Allow strings of QBXML to be passed in directly. 
     case
     when request.is_a?(Hash)
-
-      unless request.keys.include?(:qbxml_msgs_rq)
-        wrapped_request = { :qbxml_msgs_rq => {:xml_attributes => {"onError"=> QBWC::on_error } } } 
-        wrapped_request[:qbxml_msgs_rq] = wrapped_request[:qbxml_msgs_rq].merge(request)
-        request = wrapped_request
-      end
-
-      @request = QBWC.parser.hash_to_qbxml(request)
+      request = self.class.wrap_request(request)
+      @request = QBWC.parser.to_qbxml(request, {:validate => true})
     when request.is_a?(String)
       @request = request
+    else
+      raise "Request '#{request}' must be a Hash or a String."
     end
-    @response_proc = response_proc
-  end
-
-  def process_response
-    @response_proc && @response && @response_proc.call(response) 
   end
 
   def to_qbxml
-    QBWC.parser.hash_to_qbxml(request)
+    QBWC.parser.to_qbxml(request)
   end
 
   def to_hash
-    QBWC.parser.qbxml_to_hash @request.to_s
+    hash = QBWC.parser.from_qbxml(@request.to_s)["qbxml"]["qbxml_msgs_rq"]
+    hash.except('xml_attributes')
   end
 
-  class << self
-
-    def from_array(requests, response_proc)
-      Array(requests).map { |r| new(r, response_proc) } 
-    end
-
+  # Wrap a Hash request with qbxml_msgs_rq, if it's not already.
+  def self.wrap_request(request)
+    return request if request.keys.include?(:qbxml_msgs_rq)
+    wrapped_request = { :qbxml_msgs_rq => {:xml_attributes => {"onError"=> QBWC::on_error } } }
+    wrapped_request[:qbxml_msgs_rq] = wrapped_request[:qbxml_msgs_rq].merge(request)
+    return wrapped_request
   end
 
 end

data/lib/qbwc/session.rb

@@ -1,115 +1,143 @@
 class QBWC::Session
-  include Enumerable
 
-  attr_reader :current_job, :current_request, :saved_requests, :progress
-  attr_reader :qbwc_iterator_queue, :qbwc_iterating
+  attr_reader :user, :company, :ticket, :progress
+  attr_accessor :error, :status_code, :status_severity
 
   @@session = nil
 
-  def initialize
+	def self.get(ticket)
+		@@session
+	end
+
+  def initialize(user = nil, company = nil, ticket = nil)
+    @user = user
+    @company = company
     @current_job = nil
-    @current_request = nil
-    @saved_requests = []
+    @error = nil
+    @progress = 0
+    @iterator_id = nil
+    @initial_job_count = pending_jobs.length
 
-    @qbwc_iterator_queue = []
-    @qbwc_iterating = false
+    @ticket = ticket || Digest::SHA1.hexdigest("#{Rails.application.config.secret_token}#{Time.now.to_i}")
 
     @@session = self
-    reset
+    reset(ticket.nil?)
+  end
+
+  def response_is_error?
+    self.error && self.status_severity == 'Error'
   end
 
-  def reset
-    @progress = QBWC.jobs.blank? ? 100 : 0
-    enabled_jobs.map { |j| j.reset }
-    @requests = build_request_generator(enabled_jobs)
+  def error_and_stop_requested?
+    response_is_error? && QBWC::on_error == 'stopOnError'
   end
 
   def finished?
-    @progress == 100
+    self.progress == 100
+  end
+
+  def next_request
+    if current_job.nil? || error_and_stop_requested?
+      self.progress = 100
+      return nil
+    end
+    until (request = current_job.next_request) do
+      pending_jobs.shift
+      reset(true) or break
+    end
+    jobs_completed = @initial_job_count - pending_jobs.length
+    self.progress = ((jobs_completed.to_f  / @initial_job_count.to_f ) * 100).to_i
+    request
   end
+  alias :next :next_request  # Deprecated method name 'next'
+
+  def current_request
+    request = self.next_request
+    if request && self.iterator_id.present?
+      request = request.to_hash
+      request.delete('xml_attributes')
+      request.values.first['xml_attributes'] = {'iterator' => 'Continue', 'iteratorID' => self.iterator_id}
+      request = QBWC::Request.new(request)
+    end 
+    request
+  end
+
+  def request_to_send
+    current_job_name = current_job.name
+    request = current_request.try(:request) || ''
+    QBWC.logger.info("Sending request from job #{current_job_name}")
+    QBWC.logger.info(request) if QBWC.log_requests_and_responses
 
-  def next
-    @requests.alive? ? @requests.resume : nil
+    request
   end
 
   def response=(qbxml_response)
     begin
-      @current_request.response = QBWC.parser.qbxml_to_hash(qbxml_response)
-      parse_response_header(@current_request.response)
-
-      if QBWC.delayed_processing
-        @saved_requests << @current_request
-      else
-        @current_request.process_response
+      QBWC.logger.info 'Parsing response.'
+      unless qbxml_response.nil?
+        response = QBWC.parser.from_qbxml(qbxml_response)["qbxml"]["qbxml_msgs_rs"].except("xml_attributes")
+        response = response[response.keys.first]
+        parse_response_header(response)
       end
+      self.current_job.process_response(qbxml_response, response, self, iterator_id.blank?) unless self.current_job.nil?
+      self.next_request # search next request
+
     rescue => e
-      puts "An error occured in QBWC::Session: #{e}"
-      puts e
-      puts e.backtrace
+      self.error = e.message
+      QBWC.logger.warn "An error occured in QBWC::Session: #{e.message}"
+      QBWC.logger.warn e.backtrace.join("\n")
     end
+  end
 
+  def save
   end
 
-  def process_saved_responses
-    @saved_requests.each { |r| r.process_response }
+  def destroy
+    self.freeze
+    @@session = nil
   end
 
-  private
+  protected
 
-  def enabled_jobs
-    QBWC.jobs.values.select { |j| j.enabled? }
-  end
+  attr_accessor :current_job, :iterator_id
+  attr_writer :progress
 
-  def build_request_generator(jobs)
-    Fiber.new do
-      jobs.each do |j|
-        @current_job = j
-        while (r = next_request)
-          @current_request = r
-          Fiber.yield r
-        end
-      end
+  private
 
-      @progress = 100
-      nil
-    end
+  def reset(reset_job = false)
+    self.current_job = pending_jobs.first
+    self.current_job.reset if reset_job && self.current_job
+    return self.current_job
   end
 
-  def next_request
-    (@qbwc_iterating == true && @qbwc_iterator_queue.shift) || @current_job.next
+  def pending_jobs
+    @pending_jobs ||= QBWC.pending_jobs(@company)
   end
 
   def parse_response_header(response)
-    return unless response['xml_attributes']
+    QBWC.logger.info 'Parsing headers.'
 
-    status_code, status_severity, status_message, iterator_remaining_count, iterator_id = \
-      response['xml_attributes'].values_at('statusCode', 'statusSeverity', 'statusMessage', 
-                                               'iteratorRemainingCount', 'iteratorID') 
-                                               
-    if status_severity == 'Error' || status_code.to_i > 1 || response.keys.size <= 1
-      @current_request.error = "QBWC ERROR: #{status_code} - #{status_message}"
-    else
-      if iterator_remaining_count.to_i > 0
-        @qbwc_iterating = true
-        new_request = @current_request.to_hash
-        new_request.delete('xml_attributes')
-        new_request.values.first['xml_attributes'] = {'iterator' => 'Continue', 'iteratorID' => iterator_id}
-        @qbwc_iterator_queue << QBWC::Request.new(new_request, @current_request.response_proc)
-      else
-        @qbwc_iterating = false
-      end
+    self.iterator_id = nil
+    self.error = nil
+    self.status_code = nil
+    self.status_severity = nil
+
+    if response.is_a? Array
+      response = response.find {|r| r.is_a?(Hash) && r['xml_attributes'] && r['xml_attributes']['statusCode'].to_i > 1} || response.first
     end
-  end
+    return unless response.is_a?(Hash) && response['xml_attributes']
 
-class << self
+    @status_code, @status_severity, status_message, iterator_remaining_count, iterator_id = \
+      response['xml_attributes'].values_at('statusCode', 'statusSeverity', 'statusMessage', 
+                                               'iteratorRemainingCount', 'iteratorID')
+    QBWC.logger.info "Parsed headers. statusSeverity: '#{status_severity}'. statusCode: '#{@status_code}'"
 
-  def new_or_unfinished
-    (!@@session || @@session.finished?) ? new : @@session
-  end
+    if @status_severity == 'Error' || @status_severity == 'Warn'
+      self.error = "QBWC #{@status_severity.upcase}: #{@status_code} - #{status_message}"
+      @status_severity == 'Error' ? QBWC.logger.error(self.error) : QBWC.logger.warn(self.error)
+    end
 
-end
+    self.iterator_id = iterator_id if iterator_remaining_count.to_i > 0 && @status_severity != 'Error'
 
-	def self.session
-		@@session
-	end
+  end
 end