RubyGems - rt-client - Versions diffs - 0.7.5 → 0.8.0 - Mend

rt-client 0.7.5 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

data/rt_client.rb CHANGED Viewed

@@ -17,161 +17,161 @@ end
 ##default server/user/pass to connect to RT as, so that you don't have to
 ##specify it/update it in lots of different scripts.
 ##
-##Thanks to Brian McArdle for patch dealing with spaces in Custom Fields.
-##To reference custom fields in RT that have spaces with rt-client, use an
-##underscore in the rt-client code, e.g. "CF.{{Has_Space}}"
+##Thanks to the following members of the RT community for patches:
+##Brian McArdle for patch dealing with spaces in Custom Fields (use '_')
+##Steven Craig for a bug fix and feature additions to the usersearch() method.
+##Rafael Abdo for fixing a broken regex.
 ##
-##Thanks to Robert Vinson for 1.9.x compatibility when I couldn't be buggered
-##and a great job of refactoring the old mess into something with much fewer
+##Extra Special Thanks to Robert Vinson for 1.9.x compatibility when I
+##couldn't be buggered and refactoring the old mess into something with much fewer
 ##dependencies.
 ##
-##Thanks to Steven Craig for a bug fix and feature additions to the
-##usersearch() method.
 ##
 ##
 ##TODO: Streaming, chunking attachments in compose method
 #
-# See each method for sample usage.  To use this, "gem install rt-client" and
+# See each method for sample usage.  To use this, "gem install rt-client" and
 #
-#  require "rt/client"
+#  require "rt_client"
 class RT_Client
-	UA = "Mozilla/5.0 ruby RT Client Interface 0.7.5"
-	attr_reader :status, :site, :version, :cookies, :server, :user, :cookie
-	# Create a new RT_Client object. Load up our stored cookie and check it.
-	# Log into RT again if needed and store the new cookie.  You can specify
-	# login and cookie storage directories in 3 different ways:
-	# 1. Explicity during object creation
-	# 2. From a .rtclientrc file in the working directory of your ruby program
-	# 3. From a .rtclientrc file in the same directory as the library itself
-	#
-	# These are listed in order of priority; if you have explicit parameters,
-	# they are always used, even if you have .rtclientrc files.  If there
-	# is both an .rtclientrc in your program's working directory and
-	# in the library directory, the one from your program's working directory
-	# is used.  If no parameters are specified either explicity or by use
-	# of a .rtclientrc, then the defaults of "rt_user", "rt_pass" are used
-	# with a default server of "http://localhost", and cookies are stored
-	# in the directory where the library resides.
-	#
-	#  rt= RT_Client.new( :server  => "https://tickets.ambulance.com/",
-	#                     :user    => "rt_user",
-	#                     :pass    => "rt_pass",
-	#                     :cookies => "/my/cookie/dir" )
-	#
-	#  rt= RT_Client.new # use defaults from .rtclientrc
-	#
-	# .rtclientrc format:
-	#  server=<RT server>
-	#  user=<RT user>
-	#  pass=<RT password>
-	#  cookies=<directory>
-	def initialize(*params)
-		@boundary = "----xYzZY#{rand(1000000).to_s}xYzZY"
-		@version = "0.7.5"
-		@status = "Not connected"
-		@server = "http://localhost/"
-		@user = "rt_user"
-		@pass = "rt_pass"
-		@cookies = Dir.pwd
-		config_file = Dir.pwd + "/.rtclientrc"
-		config = ""
-		if File.file?(config_file)
-			config = File.read(config_file)
-		else
-			config_file = File.dirname(__FILE__) + "/.rtclientrc"
-			config = File.read(config_file) if File.file?(config_file)
-		end
-		@server = $~[1] if config =~ /\s*server\s*=\s*(.*)$/i
-		@user = $~[1] if config =~ /^\s*user\s*=\s*(.*)$/i
-		@pass = $~[1] if config =~ /^\s*pass\s*=\s*(.*)$/i
-		@cookies = $~[1] if config =~ /\s*cookies\s*=\s*(.*)$/i
-		@resource = "#{@server}REST/1.0/"
-		if params.class == Array && params[0].class == Hash
-			param = params[0]
-			@user = param[:user] if param.has_key? :user
-			@pass = param[:pass] if param.has_key? :pass
-			if param.has_key? :server
-				@server = param[:server]
-				@server += "/" if @server !~ /\/$/
-				@resource = "#{@server}REST/1.0/"
-			end
-			@cookies  = param[:cookies] if param.has_key? :cookies
-		end
-		@login = { :user => @user, :pass => @pass }
-		cookiejar = "#{@cookies}/RT_Client.#{@user}.cookie" # cookie location
-		cookiejar.untaint
-		if File.file? cookiejar
-			@cookie = File.read(cookiejar).chomp
-			headers = { 'User-Agent'   => UA,
-			'Content-Type' => "application/x-www-form-urlencoded",
-			'Cookie'       => @cookie }
-		else
-			headers = { 'User-Agent'   => UA,
-			'Content-Type' => "application/x-www-form-urlencoded" }
-			@cookie = ""
-		end
-		site = RestClient::Resource.new(@resource, :headers => headers, :timeout => 240)
-		data = site.post "" # a null post just to check that we are logged in
-		if @cookie.length == 0 or data =~ /401/ # we're not logged in
-			data = site.post @login, :headers => headers
-			#      puts data
-			@cookie = data.headers[:set_cookie].first.split('; ')[0]
-			# write the new cookie
-			if @cookie !~ /nil/
-				f = File.new(cookiejar,"w")
-				f.puts @cookie
-				f.close
-			end
-		end
-		headers = { 'User-Agent'   => UA,
-		   'Content-Type' => "multipart/form-data; boundary=#{@boundary}",
-		'Cookie'       => @cookie }
-		@site = RestClient::Resource.new(@resource, :headers => headers)
-		@status = data
-		self.untaint
-	end
-	# gets the detail for a single ticket/user.  If its a ticket, its without
-	# history or attachments (to get those use the history method) .  If no
-	# type is specified, ticket is assumed.  takes a single parameter
-	# containing the ticket/user id, and returns a hash of RT Fields => values
-	#
-	#  hash = rt.show(822)
-	#  hash = rt.show("822")
-	#  hash = rt.show("ticket/822")
-	#  hash = rt.show(:id => 822)
-	#  hash = rt.show(:id => "822")
-	#  hash = rt.show(:id => "ticket/822")
-	#  hash = rt.show("user/#{login}")
-	#  email = rt.show("user/somebody")["emailaddress"]
-	def show(id)
-		id = id[:id] if id.class == Hash
-		id = id.to_s
-		type = "ticket"
-		sid = id
-		if id =~ /(\w+)\/(.+)/
-			type = $~[1]
-			sid = $~[2]
-		end
-		reply = {}
-		if type.downcase == 'user'
-			resp = @site["#{type}/#{sid}"].get
-		else
-			resp = @site["#{type}/#{sid}/show"].get
-		end
-		reply = response_to_h(resp)
-	end
-	# gets a list of ticket links for a ticket.
-  # takes a single parameter containing the ticket id,
+  UA = "Mozilla/5.0 ruby RT Client Interface 0.8.0"
+  attr_reader :status, :site, :version, :cookies, :server, :user, :cookie
+  # Create a new RT_Client object. Load up our stored cookie and check it.
+  # Log into RT again if needed and store the new cookie.  You can specify
+  # login and cookie storage directories in 3 different ways:
+  # 1. Explicity during object creation
+  # 2. From a .rtclientrc file in the working directory of your ruby program
+  # 3. From a .rtclientrc file in the same directory as the library itself
+  #
+  # These are listed in order of priority; if you have explicit parameters,
+  # they are always used, even if you have .rtclientrc files.  If there
+  # is both an .rtclientrc in your program's working directory and
+  # in the library directory, the one from your program's working directory
+  # is used.  If no parameters are specified either explicity or by use
+  # of a .rtclientrc, then the defaults of "rt_user", "rt_pass" are used
+  # with a default server of "http://localhost", and cookies are stored
+  # in the directory where the library resides.
+  #
+  #  rt= RT_Client.new( :server  => "https://tickets.ambulance.com/",
+  #                     :user    => "rt_user",
+  #                     :pass    => "rt_pass",
+  #                     :cookies => "/my/cookie/dir" )
+  #
+  #  rt= RT_Client.new # use defaults from .rtclientrc
+  #
+  # .rtclientrc format:
+  #  server=<RT server>
+  #  user=<RT user>
+  #  pass=<RT password>
+  #  cookies=<directory>
+  def initialize(*params)
+    @boundary = "----xYzZY#{rand(1000000).to_s}xYzZY"
+    @version = "0.8.0"
+    @status = "Not connected"
+    @server = "http://localhost/"
+    @user = "rt_user"
+    @pass = "rt_pass"
+    @cookies = Dir.pwd
+    config_file = Dir.pwd + "/.rtclientrc"
+    config = ""
+    if File.file?(config_file)
+      config = File.read(config_file)
+    else
+      config_file = File.dirname(__FILE__) + "/.rtclientrc"
+      config = File.read(config_file) if File.file?(config_file)
+    end
+    @server = $~[1] if config =~ /\s*server\s*=\s*(.*)$/i
+    @user = $~[1] if config =~ /^\s*user\s*=\s*(.*)$/i
+    @pass = $~[1] if config =~ /^\s*pass\s*=\s*(.*)$/i
+    @cookies = $~[1] if config =~ /\s*cookies\s*=\s*(.*)$/i
+    @resource = "#{@server}REST/1.0/"
+    if params.class == Array && params[0].class == Hash
+      param = params[0]
+      @user = param[:user] if param.has_key? :user
+      @pass = param[:pass] if param.has_key? :pass
+      if param.has_key? :server
+        @server = param[:server]
+        @server += "/" if @server !~ /\/$/
+        @resource = "#{@server}REST/1.0/"
+      end
+      @cookies  = param[:cookies] if param.has_key? :cookies
+    end
+    @login = { :user => @user, :pass => @pass }
+    cookiejar = "#{@cookies}/RT_Client.#{@user}.cookie" # cookie location
+    cookiejar.untaint
+    if File.file? cookiejar
+      @cookie = File.read(cookiejar).chomp
+      headers = { 'User-Agent' => UA,
+      'Content-Type' => "application/x-www-form-urlencoded",
+      'Cookie'       => @cookie }
+    else
+      headers = { 'User-Agent' => UA,
+      'Content-Type' => "application/x-www-form-urlencoded" }
+      @cookie = ""
+    end
+    site = RestClient::Resource.new(@resource, :headers => headers, :timeout => 240)
+    data = site.post "" # a null post just to check that we are logged in
+    if @cookie.length == 0 or data =~ /401/ # we're not logged in
+      data = site.post @login, :headers => headers
+      # puts data
+      @cookie = data.headers[:set_cookie].first.split('; ')[0]
+      # write the new cookie
+      if @cookie !~ /nil/
+        f = File.new(cookiejar,"w")
+        f.puts @cookie
+        f.close
+      end
+    end
+    headers = { 'User-Agent'   => UA,
+      'Content-Type' => "multipart/form-data; boundary=#{@boundary}",
+      'Cookie'       => @cookie }
+    @site = RestClient::Resource.new(@resource, :headers => headers)
+    @status = data
+    self.untaint
+  end
+  # gets the detail for a single ticket/user.  If its a ticket, its without
+  # history or attachments (to get those use the history method) .  If no
+  # type is specified, ticket is assumed.  takes a single parameter
+  # containing the ticket/user id, and returns a hash of RT Fields => values
+  #
+  #  hash = rt.show(822)
+  #  hash = rt.show("822")
+  #  hash = rt.show("ticket/822")
+  #  hash = rt.show(:id => 822)
+  #  hash = rt.show(:id => "822")
+  #  hash = rt.show(:id => "ticket/822")
+  #  hash = rt.show("user/#{login}")
+  #  email = rt.show("user/somebody")["emailaddress"]
+  def show(id)
+    id = id[:id] if id.class == Hash
+    id = id.to_s
+    type = "ticket"
+    sid = id
+    if id =~ /(\w+)\/(.+)/
+      type = $~[1]
+      sid = $~[2]
+    end
+    reply = {}
+    if type.downcase == 'user'
+      resp = @site["#{type}/#{sid}"].get
+    else
+      resp = @site["#{type}/#{sid}/show"].get
+    end
+    reply = response_to_h(resp)
+  end
+  # gets a list of ticket links for a ticket.
+  # takes a single parameter containing the ticket id,
   # and returns a hash of RT Fields => values
-  #
+  #
   #  hash = rt.links(822)
   #  hash = rt.links("822")
   #  hash = rt.links("ticket/822")
@@ -207,8 +207,6 @@ class RT_Client
   def create(field_hash)
     field_hash[:id] = "ticket/new"
     payload = compose(field_hash)
-#    puts "Payload for new ticket:"
-#    puts payload
     resp = @site['ticket/new/edit'].post payload
     new_id = resp.match(/Ticket\s*(\d+)/)
     if new_id.class == MatchData
@@ -218,7 +216,7 @@ class RT_Client
     end
     new_ticket # return the ticket number, or the full REST response
   end
   # create a new user.  Requires a hash of RT fields => values. Returns
   # the newly created user ID, or the full REST response if there is an error.
   # For a full list of possible parameters that you can specify, look at
@@ -237,7 +235,7 @@ class RT_Client
     end
     new_user # return the new user id or the full REST response
   end
   # edit or create a user.  If the user exists, edits the user as "edit" would.
   # If the user doesn't exist, creates it as "create_user" would.
   def edit_or_create_user(field_hash)
@@ -257,10 +255,10 @@ class RT_Client
     resp = "Edit: #{resp1}\nCreate:#{resp2}"
     resp
   end
   # edit an existing ticket/user. Requires a hash containing RT
   # form fields as keys.  the key :id is required.
-  # returns the complete REST response, whatever it is.  If the
+  # returns the complete REST response, whatever it is.  If the
   # id supplied contains "user/", it edits a user, otherwise
   # it edits a ticket.  For a full list of fields you can edit,
   # try "/opt/rt3/bin/rt edit ticket/1"
@@ -286,7 +284,7 @@ class RT_Client
     resp = @site["#{type}/#{sid}/edit"].post payload
     resp
   end
   # Comment on a ticket.  Requires a hash, which must have an :id key
   # containing the ticket number.  Returns the REST response.  For a list of
   # fields you can use in a comment, try "/opt/rt3/bin/rt comment ticket/1"
@@ -304,7 +302,7 @@ class RT_Client
     payload = compose(field_hash)
     @site["ticket/#{id}/comment"].post payload
   end
   # Find RT user details from an email address or a name
   #
   # rt.usersearch(:EmailAddress => 'some@email.com')
@@ -322,13 +320,12 @@ class RT_Client
     return reply if resp =~ /No user named/
     reply = response_to_h(resp)
   end
   # An alias for usersearch()
   def usernamesearch(field_hash)
     usersearch(field_hash)
   end
   # correspond on a ticket.  Requires a hash, which must have an :id key
   # containing the ticket number.  Returns the REST response.  For a list of
   # fields you can use in correspondence, try "/opt/rt3/bin/rt correspond
@@ -352,91 +349,91 @@ class RT_Client
     @site["ticket/#{id}/comment"].post payload
   end
-	# Get a list of tickets matching some criteria.
-	# Takes a string Ticket-SQL query and an optional "order by" parameter.
-	# The order by is an RT field, prefix it with + for ascending
-	# or - for descending.
-	# Returns a nested array of arrays containing [ticket number, subject]
-	# The outer array is in the order requested.
-	#
-	#  hash = rt.list(:query => "Queue = 'Sales'")
-	#  hash = rt.list("Queue='Sales'")
-	#  hash = rt.list(:query => "Queue = 'Sales'", :order => "-Id")
-	#  hash = rt.list("Queue='Sales'","-Id")
-	def list(*params)
-		query = params[0]
-		order = ""
-		if params.size > 1
-			order = params[1]
-		end
-		if params[0].class == Hash
-			params = params[0]
-			query = params[:query] if params.has_key? :query
-			order = params[:order] if params.has_key? :order
-		end
-		reply = []
-		resp = @site["search/ticket/?query=#{URI.escape(query)}&orderby=#{order}&format=s"].get
-		raise "Invalid query (#{query})" if resp =~ /Invalid query/
-		resp = resp.split("\n") # convert to array of lines
-		resp.each do |line|
-			f = line.match(/^(\d+):\s*(.*)/)
-			reply.push [f[1],f[2]] if f.class == MatchData
-		end
-		reply
-	end
-	# A more extensive(expensive) query then the list method.  Takes the same
-	# parameters as the list method; a string Ticket-SQL query and optional
-	# order, but returns a lot more information.  Instead of just the ID and
-	# subject, you get back an array of hashes, where each hash represents
-	# one ticket, indentical to what you get from the show method (which only
-	# acts on one ticket).  Use with caution; this can take a long time to
-	# execute.
-	#
-	#  array = rt.query("Queue='Sales'")
-	#  array = rt.query(:query => "Queue='Sales'",:order => "+Id")
-	#  array = rt.query("Queue='Sales'","+Id")
-	#  => array[0] = { "id" => "123", "requestors" => "someone@..", etc etc }
-	#  => array[1] = { "id" => "126", "requestors" => "someone@else..", etc etc }
-	#  => array[0]["id"] = "123"
-	def query(*params)
-		query = params[0]
-		order = ""
-		if params.size > 1
-			order = params[1]
-		end
-		if params[0].class == Hash
-			params = params[0]
-			query = params[:query] if params.has_key? :query
-			order = params[:order] if params.has_key? :order
-		end
-		replies = []
-		resp = @site["search/ticket/?query=#{URI.escape(query)}&orderby=#{order}&format=l"].get
-		return replies if resp =~/No matching results./
-		raise "Invalid query (#{query})" if resp =~ /Invalid query/
-		resp.gsub!(/RT\/\d+\.\d+\.\d+\s\d{3}\s.*\n\n/,"") # strip HTTP response
-		tickets = resp.split("\n--\n") # -- occurs between each ticket
-		tickets.each do |ticket|
-			ticket_h = response_to_h(ticket)
-			reply = {}
-			ticket_h.each do |k,v|
-				case k
-				when 'created','due','told','lastupdated','started'
-					begin
-						vv = DateTime.parse(v.to_s)
-						reply["#{k}"] = vv.strftime("%Y-%m-%d %H:%M:%S")
-					rescue ArgumentError
-						reply["#{k}"] = v.to_s
-					end
-				else
-					reply["#{k}"] = v.to_s
-				end
-			end
-			replies.push reply
-		end
-		replies
-	end
+  # Get a list of tickets matching some criteria.
+  # Takes a string Ticket-SQL query and an optional "order by" parameter.
+  # The order by is an RT field, prefix it with + for ascending
+  # or - for descending.
+  # Returns a nested array of arrays containing [ticket number, subject]
+  # The outer array is in the order requested.
+  #
+  #  hash = rt.list(:query => "Queue = 'Sales'")
+  #  hash = rt.list("Queue='Sales'")
+  #  hash = rt.list(:query => "Queue = 'Sales'", :order => "-Id")
+  #  hash = rt.list("Queue='Sales'","-Id")
+  def list(*params)
+    query = params[0]
+    order = ""
+    if params.size > 1
+      order = params[1]
+    end
+    if params[0].class == Hash
+      params = params[0]
+      query = params[:query] if params.has_key? :query
+      order = params[:order] if params.has_key? :order
+    end
+    reply = []
+    resp = @site["search/ticket/?query=#{URI.escape(query)}&orderby=#{order}&format=s"].get
+    raise "Invalid query (#{query})" if resp =~ /Invalid query/
+    resp = resp.split("\n") # convert to array of lines
+    resp.each do |line|
+      f = line.match(/^(\d+):\s*(.*)/)
+      reply.push [f[1],f[2]] if f.class == MatchData
+    end
+    reply
+  end
+  # A more extensive(expensive) query then the list method.  Takes the same
+  # parameters as the list method; a string Ticket-SQL query and optional
+  # order, but returns a lot more information.  Instead of just the ID and
+  # subject, you get back an array of hashes, where each hash represents
+  # one ticket, indentical to what you get from the show method (which only
+  # acts on one ticket).  Use with caution; this can take a long time to
+  # execute.
+  #
+  #  array = rt.query("Queue='Sales'")
+  #  array = rt.query(:query => "Queue='Sales'",:order => "+Id")
+  #  array = rt.query("Queue='Sales'","+Id")
+  #  => array[0] = { "id" => "123", "requestors" => "someone@..", etc etc }
+  #  => array[1] = { "id" => "126", "requestors" => "someone@else..", etc etc }
+  #  => array[0]["id"] = "123"
+  def query(*params)
+    query = params[0]
+    order = ""
+    if params.size > 1
+      order = params[1]
+    end
+    if params[0].class == Hash
+      params = params[0]
+      query = params[:query] if params.has_key? :query
+      order = params[:order] if params.has_key? :order
+    end
+    replies = []
+    resp = @site["search/ticket/?query=#{URI.escape(query)}&orderby=#{order}&format=l"].get
+    return replies if resp =~/No matching results./
+    raise "Invalid query (#{query})" if resp =~ /Invalid query/
+    resp.gsub!(/RT\/\d+\.\d+\.\d+\s\d{3}\s.*\n\n/,"") # strip HTTP response
+    tickets = resp.split("\n--\n") # -- occurs between each ticket
+    tickets.each do |ticket|
+      ticket_h = response_to_h(ticket)
+      reply = {}
+      ticket_h.each do |k,v|
+        case k
+        when 'created','due','told','lastupdated','started'
+          begin
+            vv = DateTime.parse(v.to_s)
+            reply["#{k}"] = vv.strftime("%Y-%m-%d %H:%M:%S")
+          rescue ArgumentError
+            reply["#{k}"] = v.to_s
+          end
+        else
+          reply["#{k}"] = v.to_s
+        end
+      end
+      replies.push reply
+    end
+    replies
+  end
   # Get a list of history transactions for a ticket.  Takes a ticket ID and
   # an optional format parameter.  If the format is ommitted, the short
   # format is assumed.  If the short format is requested, it returns an
@@ -456,7 +453,7 @@ class RT_Client
   # Content::      (The content of this item)
   # Creator::      (the RT user that created this item)
   # Created::      (Date/time this item was created)
-  # Attachments::  (a hash describing attachments to this item)
+  # Attachments::  (a hash describing attachments to this item)
   #
   #  history = rt.history(881)
   #  history = rt.history(881,"short")
@@ -480,7 +477,7 @@ class RT_Client
     id = $~[1] if id =~ /ticket\/(\d+)/
     resp = @site["ticket/#{id}/history?format=#{format[0,1]}"].get
     resp = sterilize(resp)
     if format[0,1] == "s"
       if comments
         h = resp.split("\n").select{ |l| l =~ /^\d+:/ }
@@ -496,8 +493,8 @@ class RT_Client
       while resp.match(/CF\.\{[\w_ ]*[ ]+[\w ]*\}/) #replace CF spaces with underscores
         resp.gsub!(/CF\.\{([\w_ ]*)([ ]+)([\w ]*)\}/, 'CF.{\1_\3}')
       end
-      items = resp.split("\n--\n")
+      items = resp.split("\n--\n")
       list = []
       items.each do |item|
         th = response_to_h(item)
@@ -527,27 +524,27 @@ class RT_Client
               end
             when "content"
               reply["content"] = v.to_s
-              temp = item.match(/^Content: (.*?)^\w+:/m)
+              temp = item.match(/^Content: (.*?)^\w+:/m)
               reply["content"] = temp[1] if temp.class != NilClass
             else
               reply["#{k}"] = v.to_s
           end
         end
         list.push reply
-      end
+      end
     end
     list
   end
-  # Get the detail for a single history item.  Needs a ticket ID and a
+  # Get the detail for a single history item.  Needs a ticket ID and a
   # history item ID, returns a hash of RT Fields => values.  The hash
   # also contains a special key named "attachments", whose value is
   # an array of hashes, where each hash represents an attachment.  The hash
   # keys are :id, :name, and :size.
-  #
+  #
   #  x = rt.history_item(21, 6692)
   #  x = rt.history_item(:id => 21, :history => 6692)
-  #  => x = {"ticket" => "21", "creator" => "somebody", "description" =>
+  #  => x = {"ticket" => "21", "creator" => "somebody", "description" =>
   #  =>      "something happened", "attachments" => [{:name=>"file.txt",
   #  =>      :id=>"3289", size=>"651b"}, {:name=>"another.doc"... }]}
   def history_item(*params)
@@ -588,12 +585,18 @@ class RT_Client
                 s[:size] = sz[2]
               end
               attachments.push s
+              if s[:name] == 'untitled' and s[:size].to_i > 0 # this is the content in HTML, I hope
+                unt_att = get_attachment(id,s[:id])
+                if (['text/html','text/plain'].include? unt_att["contenttype"]) # hurray
+                  reply["content_html"] = sterilize(unt_att["content"])
+                end
+              end
             end
             reply["#{k}"] = attachments
           end
         when "content"
           reply["content"] = v.to_s
-          temp = resp.match(/^Content: (.*?)^\w+:/m)
+          temp = resp.match(/^Content: (.*?)^\w+:/m)
           reply["content"] = temp[1] if temp.class != NilClass
         else
           reply["#{k}"] = v.to_s
@@ -601,11 +604,11 @@ class RT_Client
     end
     reply
   end
   # Get a list of attachments related to a ticket.
   # Requires a ticket id, returns an array of hashes where each hash
   # represents one attachment.  Hash keys are :id, :name, :type, :size.
-  # You can optionally request that unnamed attachments be included,
+  # You can optionally request that unnamed attachments be included,
   # the default is to not include them.
   def attachments(*params)
     id = params[0]
@@ -625,7 +628,7 @@ class RT_Client
     end
     th = response_to_h(resp)
     list = []
-    pattern = /(\d+:\s.*?\)),/
+    pattern = /(\d+:\s.*?\))(?:,|$)/
     match = pattern.match(th['attachments'].to_s)
     while match != nil
       list.push match[0]
@@ -647,13 +650,13 @@ class RT_Client
     end
     attachments
   end
   # Get attachment content for single attachment.  Requires a ticket ID
   # and an attachment ID, which must be related.  If a directory parameter
-  # is supplied, the attachment is written to that directory.  If not,
-  # the attachment content is returned in the hash returned by the
+  # is supplied, the attachment is written to that directory.  If not,
+  # the attachment content is returned in the hash returned by the
   # function as the key 'content', along with some other keys you always get:
-  #
+  #
   # transaction:: the transaction id
   # creator::     the user id number who attached it
   # id::          the attachment id
@@ -661,7 +664,7 @@ class RT_Client
   # contenttype:: MIME content type of the attachment
   # created::     date of the attachment
   # parent::      an attachment id if this was an embedded MIME attachment
-  #
+  #
   #  x = get_attachment(21,3879)
   #  x = get_attachment(:ticket => 21, :attachment => 3879)
   #  x = get_attachment(:ticket => 21, :attachment => 3879, :dir = "/some/dir")
@@ -689,12 +692,12 @@ class RT_Client
     end
     content = resp.match(/Content:\s+(.*)/m)[1]
     content.gsub!(/\n\s{9}/,"\n") # strip leading spaces on each line
-    content.chomp!
-    content.chomp!
+    content.chomp!
+    content.chomp!
     content.chomp! # 3 carriage returns at the end
     if (RUBY_VERSION.to_f >= 1.9)
       binary = content.encode("ISO-8859-1","UTF-8", { :invalid => :replace, :undef => :replace })
-    else
+    else
       binary = Iconv.conv("ISO-8859-1","UTF-8",content) # convert encoding
     end
     if dir
@@ -706,7 +709,7 @@ class RT_Client
     end
     reply
   end
   # Add a watcher to a ticket, but only if not already a watcher.  Takes a
   # ticket ID, an email address (or array of email addresses), and an
   # optional watcher type.  If no watcher type is specified, its assumed to
@@ -756,122 +759,121 @@ class RT_Client
         edit(:id => tid, :Requestors => reqs.join(","))
     end
   end
-	# don't give up the password when the object is inspected
-	def inspect # :nodoc:
-		mystr = super()
-		mystr.gsub!(/(.)pass=.*?([,\}])/,"\\1pass=<hidden>\\2")
-		mystr
-	end
-        # helper to convert responses from RT REST to a hash
-	def response_to_h(resp) # :nodoc:
-		resp.gsub!(/RT\/\d+\.\d+\.\d+\s\d{3}\s.*\n\n/,"") # toss the HTTP response
-		# unfold folded fields
-		# A newline followed by one or more spaces is treated as a
-		# single space
-		resp.gsub!(/\n +/, " ")
-		#replace CF spaces with underscores
-		while resp.match(/CF\.\{[\w_ ]*[ ]+[\w ]*\}/)
-			resp.gsub!(/CF\.\{([\w_ ]*)([ ]+)([\w ]*)\}/, 'CF.{\1_\3}')
-		end
-		return {:error => resp }  if resp =~ /does not exist./
-		# convert fields to key value pairs
-		ret = {}
-		resp.each_line do |ln|
-			next unless ln =~ /^.+?:/
-			ln_a = ln.split(/:/,2)
-			ln_a.map! {|item| item.strip}
-			ln_a[0].downcase!
-			ret[ln_a[0]] = ln_a[1]
-		end
-		return ret
-	end
-	# Helper for composing RT's "forms".  Requires a hash where the
-	# keys are field names for an RT form.	If there's a :Text key, the value
-	# is modified to insert whitespace on continuation lines.  If there's an
-	# :Attachment key, the value is assumed to be a comma-separated list of
-	# filenames to attach.	It returns a hash to be used with rest-client's
-	# payload class
-	def compose(fields) # :nodoc:
-		if fields.class != Hash
-			raise "RT_Client.compose requires parameters as a hash."
-		end
-		payload = { :multipart => true }
-		# attachments
-		if fields.has_key? :Attachments
-			fields[:Attachment] = fields[:Attachments]
-			fields.delete :Attachments
-		end
-		if fields.has_key? :Attachment
-			filenames = fields[:Attachment].split(',')
-			attachment_num = 1
-			filenames.each do |f|
-				payload["attachment_#{attachment_num.to_s}"] = File.new(f)
-				attachment_num += 1
-			end
-			# strip paths from filenames
-			fields[:Attachment] = filenames.map {|f| File.basename(f)}.join(',')
-		end
-		# fixup Text field for RFC822 compliance
-		if fields.has_key? :Text
-			fields[:Text].gsub!(/\n/,"\n ") # insert a space on continuation lines.
-		end
-		field_array = fields.map { |k,v| "#{k}: #{v}" }
-		content = field_array.join("\n") # our form
-		payload["content"] = content
-		return payload
-	end
-        # Helper to replace control characters with string representations
-        # When Microsoft XML libraries hit these in an XML response, bad
-        # things happen.
-	def sterilize(str)
-	    str.gsub!(0x00.chr,'[NUL]')
-	    str.gsub!(0x01.chr,'[SOH]')
-	    str.gsub!(0x02.chr,'[STX]')
-	    str.gsub!(0x03.chr,'[ETX]')
-	    str.gsub!(0x04.chr,'[EOT]')
-	    str.gsub!(0x05.chr,'[ENQ]')
-	    str.gsub!(0x06.chr,'[ACK]')
-	    str.gsub!(0x07.chr,'[BEL]')
-	    # 0x08 is backspace
-	    # 0x09 is TAB
-	    # 0x10 is line feed
-	    str.gsub!(0x0B.chr,'[VT]')
-	    # 0x0c is form feed
-	    # 0x0d is carriage return
-	    str.gsub!(0x0E.chr,'[SO]')
-	    str.gsub!(0x0F.chr,'[SI]')
-	    str.gsub!(0x10.chr,'[DLE]')
-	    str.gsub!(0x11.chr,'[DC1]')
-	    str.gsub!(0x12.chr,'[DC2]')
-	    str.gsub!(0x13.chr,'[DC3]')
-	    str.gsub!(0x14.chr,'[DC4]')
-	    str.gsub!(0x15.chr,'[NAK]')
-	    str.gsub!(0x16.chr,'[SYN]')
-	    str.gsub!(0x17.chr,'[ETB]')
-	    str.gsub!(0x18.chr,'[CAN]')
-	    str.gsub!(0x19.chr,'[EM]')
-	    str.gsub!(0x1a.chr,'[SUB]')
-	    str.gsub!(0x1C.chr,'[FS]')
-	    str.gsub!(0x1D.chr,'[GS]')
-	    str.gsub!(0x1E.chr,'[RS]')
-	    str.gsub!(0x1F.chr,'[US]')
-	    str
-	end
-end
+  # don't give up the password when the object is inspected
+  def inspect # :nodoc:
+    mystr = super()
+    mystr.gsub!(/(.)pass=.*?([,\}])/,"\\1pass=<hidden>\\2")
+    mystr
+  end
+  # helper to convert responses from RT REST to a hash
+  def response_to_h(resp) # :nodoc:
+    resp.gsub!(/RT\/\d+\.\d+\.\d+\s\d{3}\s.*\n\n/,"") # toss the HTTP response
+    # unfold folded fields
+    # A newline followed by one or more spaces is treated as a
+    # single space
+    resp.gsub!(/\n +/, " ")
+    #replace CF spaces with underscores
+    while resp.match(/CF\.\{[\w_ ]*[ ]+[\w ]*\}/)
+      resp.gsub!(/CF\.\{([\w_ ]*)([ ]+)([\w ]*)\}/, 'CF.{\1_\3}')
+    end
+    return {:error => resp }  if resp =~ /does not exist./
+    # convert fields to key value pairs
+    ret = {}
+    resp.each_line do |ln|
+      next unless ln =~ /^.+?:/
+      ln_a = ln.split(/:/,2)
+      ln_a.map! {|item| item.strip}
+      ln_a[0].downcase!
+      ret[ln_a[0]] = ln_a[1]
+    end
+    return ret
+  end
+  # Helper for composing RT's "forms".  Requires a hash where the
+  # keys are field names for an RT form.  If there's a :Text key, the value
+  # is modified to insert whitespace on continuation lines.  If there's an
+  # :Attachment key, the value is assumed to be a comma-separated list of
+  # filenames to attach.  It returns a hash to be used with rest-client's
+  # payload class
+  def compose(fields) # :nodoc:
+    if fields.class != Hash
+      raise "RT_Client.compose requires parameters as a hash."
+    end
+    payload = { :multipart => true }
+    # attachments
+    if fields.has_key? :Attachments
+      fields[:Attachment] = fields[:Attachments]
+      fields.delete :Attachments
+    end
+    if fields.has_key? :Attachment
+      filenames = fields[:Attachment].split(',')
+      attachment_num = 1
+      filenames.each do |f|
+        payload["attachment_#{attachment_num.to_s}"] = File.new(f)
+        attachment_num += 1
+      end
+      # strip paths from filenames
+      fields[:Attachment] = filenames.map {|f| File.basename(f)}.join(',')
+    end
+    # fixup Text field for RT's quasi-RFC822 form
+    if fields.has_key? :Text
+      fields[:Text].gsub!(/\n/,"\n ") # insert a space on continuation lines.
+    end
+    field_array = fields.map { |k,v| "#{k}: #{v}" }
+    content = field_array.join("\n") # our form
+    payload["content"] = content
+    return payload
+  end
+  # Helper to replace control characters with string representations
+  # When some XML libraries hit these in an XML response, bad things happen.
+  def sterilize(str)
+      str.encode!('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+      str.gsub!(0x00.chr,'[NUL]')
+      str.gsub!(0x01.chr,'[SOH]')
+      str.gsub!(0x02.chr,'[STX]')
+      str.gsub!(0x03.chr,'[ETX]')
+      str.gsub!(0x04.chr,'[EOT]')
+      str.gsub!(0x05.chr,'[ENQ]')
+      str.gsub!(0x06.chr,'[ACK]')
+      str.gsub!(0x07.chr,'[BEL]')
+      # 0x08 is backspace
+      # 0x09 is TAB
+      # 0x10 is line feed
+      str.gsub!(0x0B.chr,'[VT]')
+      # 0x0c is form feed
+      # 0x0d is carriage return
+      str.gsub!(0x0E.chr,'[SO]')
+      str.gsub!(0x0F.chr,'[SI]')
+      str.gsub!(0x10.chr,'[DLE]')
+      str.gsub!(0x11.chr,'[DC1]')
+      str.gsub!(0x12.chr,'[DC2]')
+      str.gsub!(0x13.chr,'[DC3]')
+      str.gsub!(0x14.chr,'[DC4]')
+      str.gsub!(0x15.chr,'[NAK]')
+      str.gsub!(0x16.chr,'[SYN]')
+      str.gsub!(0x17.chr,'[ETB]')
+      str.gsub!(0x18.chr,'[CAN]')
+      str.gsub!(0x19.chr,'[EM]')
+      str.gsub!(0x1a.chr,'[SUB]')
+      str.gsub!(0x1C.chr,'[FS]')
+      str.gsub!(0x1D.chr,'[GS]')
+      str.gsub!(0x1E.chr,'[RS]')
+      str.gsub!(0x1F.chr,'[US]')
+      str
+  end
+end

data/rtxmlsrv.rb CHANGED Viewed

@@ -5,7 +5,7 @@
 ## around the rt/client library.
 require "rubygems"             # so we can load gems
-require "rt_client/rt_client"            # rt-client REST library
+require "rt_client/rt_client"  # rt-client REST library
 require "xmlrpc/server"        # that's what we're doing
 require "date"                 # for parsing arbitrary date formats

data/rtxmlsrv2.rb ADDED Viewed

@@ -0,0 +1,277 @@
+## XML RPC service to provide a cross-platform API for
+## RT ticket creation/maintenance.  Essentially just a wrapper
+## around the rt/client library.
+require "rubygems"             # so we can load gems
+require "rt_client/rt_client"  # rt-client REST library
+require "builder"
+require "rack/rpc"
+require "date"                 # for parsing arbitrary date formats
+# extend the Hash class to
+# translate string keys into symbol keys
+class Hash # :nodoc:
+  def remapkeys!
+    n = Hash.new
+    self.each_key do |key|
+      n[key.to_sym] = self[key]
+    end
+    self.replace(n)
+    n = nil
+    $stderr.puts self.map { |k,v| "#{k} => #{v}" }
+    self
+  end
+end
+class TicketSrv < Rack::RPC::Server
+  # Allows watchers to be added via RT_Client::add_watcher
+  # You need to pass :id, :addr, and optionally :type
+  def add_watcher(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.add_watcher(struct)
+    rt = nil
+    val
+  end
+  # Gets a list of attachments via RT_Client::attachments
+  # You need to pass :id, and optionally :unnamed
+  def attachments(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    rt = RT_Client.new
+    val = rt.attachments(struct)
+    rt = nil
+    val
+  end
+  # Adds comments to tickets via RT_Client::comment
+  def comment(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.comment(struct)
+    rt = nil
+    val
+  end
+  # Allows new tickets to be created via RT_Client::correspond
+  def correspond(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.correspond(struct)
+    rt = nil
+    val
+  end
+  # Allows new tickets to be created via RT_Client::create
+  def create(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.create(struct)
+    rt = nil
+    val
+  end
+  # Allows new users to be created via RT_Client::create_user
+  def create_user(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.create_user(struct)
+    rt = nil
+    val
+  end
+  # Find RT user details from email address via RT_Cleint::usersearch
+  def usersearch(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.usersearch(struct)
+    rt = nil
+    val
+  end
+  # Allows new users to be edited or created if they don't exist
+  def edit_or_create_user(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.edit_or_create_user(struct)
+    rt = nil
+    val
+  end
+  # Allows existing ticket to be modified via RT_Client::edit
+  def edit(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.edit(struct)
+    rt = nil
+    val
+  end
+  # Retrieves attachments via RT_Client::get_attachment
+  def get_attachment(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.get_attachment(struct)
+    rt = nil
+    val
+  end
+  # Gets the history of a ticket via RT_Client::history
+  def history(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.history(struct)
+    rt = nil
+    val
+  end
+  # Gets a single history item via RT_Client::history_item
+  def history_item(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.history_item(struct)
+    rt = nil
+    val
+  end
+  # Gets a list of tickets via RT_Client::list
+  def list(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.list(struct)
+    rt = nil
+    val
+  end
+  # Gets a list of tickets via RT_Client::query
+  def query(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.query(struct)
+    rt = nil
+    val
+  end
+  # Gets detail (minus history/attachments) via RT_Client::show
+  def show(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+      struct.delete(:user)
+      struct.delete(:pass)
+    else
+      rt = RT_Client.new
+    end
+    val = rt.show(struct)
+    rt = nil
+    val
+  end
+  interface = [ 'add_watcher', 'attachments', 'comment', 'correspond', 'create', 'create_user',
+    'edit', 'edit_or_create_user', 'get_attachment', 'history', 'history_item', 'list', 'query',
+    'show' ]
+  interface.each do |meth|
+#    rpc meth => meth.to_sym
+    rpc "rt.#{meth}" => meth.to_sym
+  end
+end # class TicketSrv
+#######################################################
+class RTXMLApp
+  def call(env)
+    [200, {'Content-Type' => 'text/xml'}, ['RT XML-RPC Service']]
+  end
+end

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rt-client
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.8.0
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-03-07 00:00:00.000000000 Z
+date: 2014-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -37,6 +37,7 @@ extra_rdoc_files: []
 files:
 - rt_client.rb
 - rtxmlsrv.rb
+- rtxmlsrv2.rb
 - rt/client.rb
 - .yardopts
 homepage: http://rubygems.org/gems/rt-client
@@ -69,3 +70,4 @@ signing_key:
 specification_version: 4
 summary: Ruby object for RT access via REST
 test_files: []
+has_rdoc: