brownpapertickets 0.0.1

data/lib/brownpapertickets/event.rb

@@ -0,0 +1,229 @@
+require 'hpricot'
+module BrownPaperTickets
+ class Event 
+   include HTTParty
+   
+   base_uri "https://www.brownpapertickets.com/api2" 
+   
+    attr_reader :attributes, :server_response
+    
+    REQUIRED_ATTR=["e_name","e_city","e_state", "e_short_description", "e_description"]
+    
+    ATTRS=["e_name","e_city","e_state", "e_short_description", "e_description","e_address1","e_address2","e_zip","e_phone","e_web","end_of_event_message",
+            "end_of_sale_message","date_notes","e_notes","keywords","c_name","c_email","c_phone","c_fax","c_address1","c_address2","c_city","c_state","c_zip",
+            "c_country","public", "title","link", "description", "event_id", "tickets_sold"]
+    
+    def initialize(id, account, attributes={})
+      @@id       = id
+      @@account  = account
+      @attributes = attributes
+    end
+    
+    def new(params={})
+      Event.new(@@id,@@account, params)
+    end
+    
+    def all
+      events = Event.get("/eventlist", :query =>{"id" => @@id , "account" => @@account })
+      parsed_event = []
+      events.parsed_response["document"]["event"].each do |event|
+        parsed_event << Event.new(@id,@account, event)
+      end
+      return parsed_event
+    end
+    
+    def find(event_id)
+      event = Event.get("/eventlist",:query =>{"id" => @@id , "account" => @@account, "event_id" => event_id })
+      @attributes = event.parsed_response["document"]["event"]
+      return self
+    end
+    
+    def method_missing(m, *args, &block)
+      if ATTRS.include?(m.to_s.gsub("=",""))
+        if m.to_s.include?("=")
+          self.attributes[m.to_s.gsub("=","")] = *args.to_s
+        else
+          result = self.attributes[m.to_s]
+        end
+      else
+        raise NoMethodError.new("Method missing #{m}")
+      end
+    end
+    
+    def validates_required_attr
+      missing_field = []
+      REQUIRED_ATTR.each do |attr|
+        missing_field << attr if self.send(attr,nil,nil).blank?
+      end
+      unless missing_field.blank?
+        @server_response = "The following attributes are missing:"
+        missing_field.each{|att| @server_response = @server_response + " " + att }
+        return false
+      end
+      return true
+    end
+    
+    #   Response while saving
+    # 	300036 - Required variables are missing
+  	#   300037 - Unknown error while posting info to DB
+  	#   000000 - Success
+    
+    def save!
+      if self.event_id.blank?
+        #changeevent
+        return false unless validates_required_attr
+        new_save("createevent")
+      else
+        #createevent
+        new_save("changeevent")
+      end
+    end
+      
+    def new_save(param)    
+      body = {"id" => @@id, "account" => @@account}
+      query = self.attributes.merge("id" => @@id, "account" => @@account)
+      response = BrownPaperTickets::Httpost.new(Net::HTTP::Post, "https://www.brownpapertickets.com/api2/#{param}",:query => query)
+      response.options[:body] = query
+      st = response.perform
+      xml = Hpricot(st.response.body)
+      
+      if param == "createevent"
+        event_id = (xml/:event_id).inner_html if (xml/:resultcode).inner_html == "000000"
+        process_create_response( (xml/:resultcode).inner_html, event_id)
+        p event_id
+      else
+        process_update_response( (xml/:resultcode).inner_html)
+      end
+    end  
+    
+    def title=(param)
+      self.attributes["e_name"] = param
+      self.attributes["title"]  = param
+    end
+    
+    def e_name=(param)
+      self.attributes["e_name"] = param
+      self.attributes["title"]  = param
+    end
+      
+    def create(params={})
+      event = Event.new(@@id,@@account, params)
+      event.save!
+    end
+      
+    def live
+      return true if self.attributes["live"] == "y"
+      return false
+    end
+    
+    def live=(param)
+      if param
+        self.attributes["live"] = "y"
+      else
+        self.attributes["live"] = "f"
+      end 
+    end  
+      
+    def public
+      return true if self.attributes["public"] == "t"
+      return false
+    end
+
+    def public=(param)
+      if param
+        self.attributes["public"] = "t"
+      else
+        self.attributes["public"] = "n"
+      end 
+    end  
+    
+    # resultcode
+    #  	  300049 - Required variables are missing
+    # 	  300050 - Unknown error
+    #	  	300051 - Unable to find event
+    #	  	300052 - Event does not belong to account
+    #	  	300053 - Required variables are missing
+    #	  	300054 - Unable to update event
+    #     000000 - Success
+    
+    def update_attribute(key, value)
+      assign = key.to_s + "="
+      self.send(assign,value)
+      query = {"id" => @@id, "account" => @@account, key.to_s => value, "event_id" => self.event_id}
+      response = BrownPaperTickets::Httpost.new(Net::HTTP::Post, "https://www.brownpapertickets.com/api2/changeevent",:query => query)
+      response.options[:body] = query
+      st = response.perform
+      xml = Hpricot(st.response.body)
+      return process_update_response((xml/:resultcode).inner_html)
+    end
+    
+    def update_attributes(params)
+      params.each do |key, value|
+        assign = key.to_s + "="
+        self.send(assign,value)
+      end
+      query = {"id" => @@id, "account" => @@account,  "event_id" => self.event_id}.merge(params)
+      response = BrownPaperTickets::Httpost.new(Net::HTTP::Post, "https://www.brownpapertickets.com/api2/changeevent",:query => query)
+      response.options[:body] = query
+      st = response.perform
+      xml = Hpricot(st.response.body)
+      return process_update_response((xml/:resultcode).inner_html)
+    end
+    
+    def process_update_response(response)
+      case response
+      when "000000" then
+        @server_response = "success"
+        return true
+      when "300049" then
+        @server_response = "Required variables are missing"
+        return false
+      when "300050" then
+        @server_response = "Unknown error"
+        return false
+      when "300051" then
+        @server_response = "Unable to find event"
+        return false
+      when "300052" then
+        @server_response = "Event does not belong to account"
+        return false
+      when "300053" then
+        @server_response = "Required variables are missing"
+        return false
+      when "300054" then
+        @server_response = "Unable to update event"
+        return false      
+      else
+        @server_response = "Unknown error"
+        return false                            
+      end
+    end
+    
+    def process_create_response(response, event_id)
+      case response
+      when "000000" then
+        self.event_id = event_id
+        @server_response = "success"
+        return true
+       when "300036" then
+        @server_response = "There are some missing attr"
+        return false
+      when "300037" then
+        @server_response = "Unknown error while posting info to DB"
+        return false
+      else
+        @server_response = "Unknown error"
+        return false
+      end
+    end
+    
+    def server_response
+      @server_response
+    end
+    
+    def attributes
+      @attributes
+    end
+    
+  end
+end

data/lib/brownpapertickets/httpost.rb

@@ -0,0 +1,215 @@
+module BrownPaperTickets
+  class Httpost < HTTParty::Request
+    
+    SupportedHTTPMethods = [
+      Net::HTTP::Get,
+      Net::HTTP::Post,
+      Net::HTTP::Put,
+      Net::HTTP::Delete,
+      Net::HTTP::Head,
+      Net::HTTP::Options
+    ]
+
+    SupportedURISchemes  = [URI::HTTP, URI::HTTPS]
+
+    attr_accessor :http_method, :path, :options, :last_response, :redirect
+
+    def initialize(http_method, path, o={})
+      super
+    end
+
+    def path=(uri)
+      @path = URI.parse(uri)
+    end
+
+    def uri
+      new_uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
+
+      # avoid double query string on redirects [#12]
+      unless redirect
+        new_uri.query = query_string(new_uri)
+      end
+
+      unless SupportedURISchemes.include? new_uri.class
+        raise UnsupportedURIScheme, "'#{new_uri}' Must be HTTP or HTTPS"
+      end
+
+      new_uri
+    end
+
+    def format
+      options[:format] || (format_from_mimetype(last_response['content-type']) if last_response)
+    end
+
+    def parser
+      options[:parser]
+    end
+
+    def perform
+      validate
+      setup_raw_request
+      get_response
+      return self.last_response
+      #handle_response
+    end
+    
+    #def body
+    #  options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
+    #end
+
+    private
+
+    def http
+      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+      http.use_ssl = ssl_implied?
+
+      if options[:timeout] && options[:timeout].is_a?(Integer)
+        http.open_timeout = options[:timeout]
+        http.read_timeout = options[:timeout]
+      end
+
+      if options[:pem] && http.use_ssl?
+        http.cert = OpenSSL::X509::Certificate.new(options[:pem])
+        http.key = OpenSSL::PKey::RSA.new(options[:pem])
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      if options[:debug_output]
+        http.set_debug_output(options[:debug_output])
+      end
+
+      http
+    end
+
+    def ssl_implied?
+      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+    end
+
+    def body
+      options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
+    end
+
+    def credentials
+      options[:basic_auth] || options[:digest_auth]
+    end
+
+    def username
+      credentials[:username]
+    end
+
+    def password
+      credentials[:password]
+    end
+
+    def setup_raw_request
+      @raw_request = http_method.new(uri.request_uri)
+      @raw_request.body = body if body
+      @raw_request.initialize_http_header(options[:headers])
+      @raw_request.basic_auth(username, password) if options[:basic_auth]
+      setup_digest_auth if options[:digest_auth]
+    end
+
+    def setup_digest_auth
+      res = http.head(uri.request_uri, options[:headers])
+      if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
+        @raw_request.digest_auth(username, password, res)
+      end
+    end
+
+    def perform_actual_request
+      http.request(@raw_request)
+    end
+
+    def get_response
+      self.last_response = perform_actual_request
+    end
+
+    def query_string(uri)
+      query_string_parts = []
+      query_string_parts << uri.query unless uri.query.nil?
+
+      if options[:query].is_a?(Hash)
+        query_string_parts << options[:default_params].merge(options[:query]).to_params
+      else
+        query_string_parts << options[:default_params].to_params unless options[:default_params].empty?
+        query_string_parts << options[:query] unless options[:query].nil?
+      end
+
+      query_string_parts.size > 0 ? query_string_parts.join('&') : nil
+    end
+
+    # Raises exception Net::XXX (http error code) if an http error occured
+    def handle_response
+      handle_deflation
+      case last_response
+      when Net::HTTPMultipleChoice, # 300
+        Net::HTTPMovedPermanently, # 301
+        Net::HTTPFound, # 302
+        Net::HTTPSeeOther, # 303
+        Net::HTTPUseProxy, # 305
+        Net::HTTPTemporaryRedirect
+        if last_response.key?('location')
+          options[:limit] -= 1
+          self.path = last_response['location']
+          self.redirect = true
+          self.http_method = Net::HTTP::Get unless options[:maintain_method_across_redirects]
+          capture_cookies(last_response)
+          perform
+        else
+          last_response
+        end
+      else
+        Response.new(last_response, parse_response(last_response.body))
+      end
+    end
+
+    # Inspired by Ruby 1.9
+    def handle_deflation
+      case last_response["content-encoding"]
+      when "gzip"
+        body_io = StringIO.new(last_response.body)
+        last_response.body.replace Zlib::GzipReader.new(body_io).read
+      when "deflate"
+        last_response.body.replace Zlib::Inflate.inflate(last_response.body)
+      end
+    end
+
+    def parse_response(body)
+      parser.call(body, format)
+    end
+
+    def capture_cookies(response)
+      return unless response['Set-Cookie']
+      cookies_hash = HTTParty::CookieHash.new()
+      cookies_hash.add_cookies(options[:headers]['Cookie']) if options[:headers] && options[:headers]['Cookie']
+      cookies_hash.add_cookies(response['Set-Cookie'])
+      options[:headers] ||= {}
+      options[:headers]['Cookie'] = cookies_hash.to_cookie_string
+    end
+
+    # Uses the HTTP Content-Type header to determine the format of the
+    # response It compares the MIME type returned to the types stored in the
+    # SupportedFormats hash
+    def format_from_mimetype(mimetype)
+      if mimetype && parser.respond_to?(:format_from_mimetype)
+        parser.format_from_mimetype(mimetype)
+      end
+    end
+
+      def validate
+        raise HTTParty::RedirectionTooDeep.new(last_response), 'HTTP redirects too deep' if options[:limit].to_i <= 0
+        raise ArgumentError, 'only get, post, put, delete, head, and options methods are supported' unless SupportedHTTPMethods.include?(http_method)
+        raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].is_a?(Hash)
+        raise ArgumentError, 'only one authentication method, :basic_auth or :digest_auth may be used at a time' if options[:basic_auth] && options[:digest_auth]
+        raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
+        raise ArgumentError, ':digest_auth must be a hash' if options[:digest_auth] && !options[:digest_auth].is_a?(Hash)
+        raise ArgumentError, ':query must be hash if using HTTP Post' if post? && !options[:query].nil? && !options[:query].is_a?(Hash)
+      end
+
+    def post?
+      Net::HTTP::Post == http_method
+    end
+  end
+end

data/lib/brownpapertickets/price.rb

@@ -0,0 +1,225 @@
+require 'hpricot'
+module BrownPaperTickets
+  class Price 
+   include HTTParty
+   base_uri "https://www.brownpapertickets.com/api2" 
+ 
+    attr_reader :attributes, :server_response
+  
+    REQUIRED_ATTR=["price", "price_name"]
+  
+    ATTRS=["price", "price_name", "event_id", "date_id", "price_id"]
+  
+    def initialize(id, account, attributes={})
+      @@id       = id
+      @@account  = account
+      @attributes = attributes
+    end
+  
+    def new(params={})
+      Event.new(@@id,@@account, params, event_id, date_id)
+    end
+  
+    def all
+      prices = Event.get("/pricelist", :query =>{"id" => @@id , "account" => @@account, "event_id" => event_id , "date_id" => date_id})
+      parsed_date = []
+      price.parsed_response["document"]["price"].each do |date|
+        parsed_date << Event.new(@id,@account, price)
+      end
+      return parsed_event
+    end
+  
+    def find(event_id)
+      price = Event.get("/pricelist",:query =>{"id" => @@id , "account" => @@account, "event_id" => event_id, "date_id"=>date_id})
+      @attributes = event.parsed_response["document"]["event"]
+      return self
+    end
+  
+    def method_missing(m, *args, &block)
+      if ATTRS.include?(m.to_s.gsub("=",""))
+        if m.to_s.include?("=")
+          self.attributes[m.to_s.gsub("=","")] = *args.to_s 
+        else
+          result = self.attributes[m.to_s]
+        end
+      else
+        raise NoMethodError.new("Method missing #{m}")
+      end
+    end
+  
+    def validates_required_attr
+      missing_field = []
+      REQUIRED_ATTR.each do |attr|
+        missing_field << attr if self.send(attr,nil,nil).blank?
+      end
+      unless missing_field.blank?
+        @server_response = "The following attributes are missing:"
+        missing_field.each{|att| @server_response = @server_response + " " + att }
+        return false
+      end
+      return true
+    end
+  
+    #   Response while saving
+    # 	300036 - Required variables are missing
+  	#   300037 - Unknown error while posting info to DB
+  	#   000000 - Success
+  
+    def save!
+      new_save("addprice")
+      p "save1"*12
+    end
+    
+    def new_save(param)
+      body = {"id" => @@id, "account" => @@account, "event_id" => event_id, "date_id"=> date_id}
+      query = self.attributes.merge("id" => @@id, "account" => @@account)
+      response = BrownPaperTickets::Httpost.new(Net::HTTP::Post, "https://www.brownpapertickets.com/api2/#{param}",:query => query)
+      response.options[:body] = query
+      st = response.perform
+      xml = Hpricot(st.response.body)
+    
+      if param == "addprice"
+        p "algo"*12
+        self.price_id = (xml/:price_id).inner_html if (xml/:resultcode).inner_html == "000000"
+        process_create_response( (xml/:resultcode).inner_html, price_id)
+        p (xml/:resultcode).inner_html
+      else
+        process_update_response( (xml/:resultcode).inner_html)
+      end
+    end  
+    
+    def create(params={})
+      price = Event.new(@@id,@@account, params)
+      price.save!
+    end
+    
+    def live
+      return true if self.attributes["live"] == "y"
+      return false
+    end
+  
+    def live=(param)
+      if param
+        self.attributes["live"] = "y"
+      else
+        self.attributes["live"] = "f"
+      end 
+    end  
+    
+    def public
+      return true if self.attributes["public"] == "t"
+      return false
+    end
+
+    def public=(param)
+      if param
+        self.attributes["public"] = "t"
+      else
+        self.attributes["public"] = "n"
+      end 
+    end  
+  
+    # resultcode
+    #  	  300049 - Required variables are missing
+    # 	  300050 - Unknown error
+    #	  	300051 - Unable to find event
+    #	  	300052 - Event does not belong to account
+    #	  	300053 - Required variables are missing
+    #	  	300054 - Unable to update event
+    #     000000 - Success
+  
+    def update_attribute(key, value)
+      assign = key.to_s + "="
+      self.send(assign,value)
+      query = {"id" => @@id, "account" => @@account, key.to_s => value, "event_id" => self.event_id}
+      response = BrownPaperTickets::Httpost.new(Net::HTTP::Post, "https://www.brownpapertickets.com/api2/changeprice",:query => query)
+      response.options[:body] = query
+      st = response.perform
+      xml = Hpricot(st.response.body)
+      return process_update_response((xml/:resultcode).inner_html)
+    end
+  
+    def update_attributes(params)
+      params.each do |key, value|
+        assign = key.to_s + "="
+        self.send(assign,value)
+      end
+      query = {"id" => @@id, "account" => @@account,  "event_id" => self.event_id}.merge(params)
+      response = BrownPaperTickets::Httpost.new(Net::HTTP::Post, "https://www.brownpapertickets.com/api2/changeprice",:query => query)
+      response.options[:body] = query
+      st = response.perform
+      xml = Hpricot(st.response.body)
+      return process_update_response((xml/:resultcode).inner_html)
+    end
+  
+    def process_update_response(response)
+      case response
+      when "000000" then
+        @server_response = "Success"
+        return true
+      when "300063" then
+        @server_response = "Required variables are missing"
+        return false
+      when "300064" then
+        @server_response = "Unable to find event"
+        return false
+      when "300065" then
+        @server_response = "Event does not belong to account"
+        return false
+      when "300066" then
+        @server_response = "Unknown error"
+        return false
+      when "300067" then
+        @server_response = "No such price for this event"
+        return false
+      when "300068" then
+        @server_response = "Required variables are missing"
+        return false   
+      when "300069" then
+        @server_response = "Unable to change price"
+        return false 
+      else
+        @server_response = "Unknown error"
+        return false                            
+      end
+    end
+  
+    def process_create_response(response, event_id)
+      case response
+      when "0000" then
+        self.event_id = event_id
+        @server_response = "success"
+        return true
+       when "300042" then
+        @server_response = "Required variables are missing"
+        return false
+      when "300043" then
+        @server_response = "Unknown error while posting info to DB"
+        return false
+      when "300044" then
+        @server_response = "Event does not belong to account"
+        return false
+      when "300045" then
+        @server_response = "Unknown error while fetching date info from DB"
+        return false
+       when "300046" then
+          @server_response = "Unable to find date"
+          return false
+       when "300047" then
+          @server_response = "Unable to add price"
+          return false
+      else
+        @server_response = "Unknown error"
+        return false
+      end
+    end
+  
+    def server_response
+      @server_response
+    end
+  
+    def attributes
+      @attributes
+    end 
+  end
+end