otrs_proxy 0.0.2

data/lib/otrs_connector/otrs/config_item.rb

@@ -0,0 +1,189 @@
+module OtrsConnector
+  class OTRS::ConfigItem < OTRS
+    
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        # cannot have numbers at beginning of field name
+        unless name =~ /^\d+/ or name =~ / / or name =~ /-/
+          self.class.set_accessor(name)
+          send("#{name.to_sym}=", value)
+        end
+      end
+    end
+    
+    def create(attributes)
+      #params = "Object=ConfigItemObject&Method=ConfigItemAdd&Data={\"ClassID\":\"#{self.ClassID}\",\"UserID\":\"1\"}"
+      data = { 'ClassID' => self.ClassID, 'UserID' => 1 }
+      params = { :object => 'ConfigItemObject', :method => 'ConfigItemAdd', :data => data }
+      a = self.class.connect(params)
+      attributes[:ConfigItemID] = a.first
+      attributes[:XMLData] = self.class.to_otrs_xml(attributes)
+      data2 = attributes
+      #params2 = "Object=ConfigItemObject&Method=VersionAdd&Data=#{data}"
+      params2 = { :object => 'ConfigItemObject', :method => 'VersionAdd', :data => data2 }
+      b = self.class.connect(params2)
+      new_version_id = b.first
+      config_item = self.class.find(attributes[:ConfigItemID])
+      attributes = config_item.attributes
+      attributes.each do |key,value|
+        instance_variable_set "@#{key.to_s}", value
+      end
+      config_item
+    end
+    
+    def self.where(attributes)
+      tmp = {}
+      attributes.each do |key,value|
+        tmp[key.to_s.camelize.to_sym] = value
+      end
+      data = tmp
+      #params = "Object=ConfigItemObject&Method=ConfigItemSearchExtended&Data=#{data}"
+      params = { :object => 'ConfigItemObject', :method => 'ConfigItemSearchExtended', :data => data }
+      a = connect(params).flatten
+      results = []
+      a.each do |b|
+        results << find(b)
+      end
+      results
+    end
+    
+    def self.to_otrs_xml(attributes)
+      xml = attributes.except(:Name,:DeplStateID,:InciStateID,:DefinitionID,
+        :CreateTime,:ChangeBy,:ChangeTime,:Class,:ClassID,:ConfigItemID,:CreateBy,:CreateTime,
+        :CurDeplState,:CurDeplStateID,:CurDeplStateType,:CurInciState,:CurInciStateID,:CurInciStateType,
+        :DeplState,:DeplStateType,:InciState,:InciStateType,:LastVersionID,:Number,:VersionID)
+      xml_hash = {}
+      xml_data = [nil, { 'Version' => xml_hash }]
+      tmp = []
+      xml.each do |key,value|
+        key = key.to_s
+        tmp << key
+      end
+      # Order keys properly so they are parsed in the correct order
+      tmp.sort! { |x,y| x <=> y }
+      tmp.each do |key|
+        keys = key.split(/__/)
+        xml_key = keys[0]
+        unless keys[1].nil? then tag_key = keys[1].gsub(/^0/,'').to_i + 1 end
+        xml_subkey = keys[2]
+        case key
+        when /^[aA-zZ]+__0\d+__[aA-zZ]+__0\d+$/
+          if xml_hash[xml_key][tag_key][xml_subkey].nil?
+            xml_hash[xml_key][tag_key][xml_subkey] = [nil, { "Content" => xml[key.to_sym] }]
+          else
+            xml_hash[xml_key][tag_key][xml_subkey] << { "Content" => xml[key.to_sym] }
+          end
+        when /^[aA-zZ]+__0\d+__[aA-zZ]$/
+          xml_hash[xml_key][tag_key][xml_subkey] = xml[key.to_sym]
+        when /^[aA-zZ]+__0\d+$/
+          if xml_hash[xml_key].nil?
+            xml_hash[xml_key] = [nil] 
+          end
+          xml_hash[xml_key] << { "Content" => xml[key.to_sym] }
+        when /^[aA-zZ]+__[aA-zZ]$/
+          xml_hash[xml_key][1][xml_subkey] = xml[key.to_sym]
+        when /^[aA-zZ]+$/
+          xml_hash[xml_key] = [ nil, { "Content" => xml[key.to_sym] }]
+        end
+      end
+      xml_data
+    end
+    
+    def update_attributes(updated_attributes)
+      self.attributes.each do |key,value|
+        if updated_attributes[key].nil?
+          updated_attributes[key] = value
+        end
+      end
+      updated_attributes[:XMLData] = self.class.to_otrs_xml(updated_attributes)
+      xml_attributes = self.attributes.except(:Name,:DeplStateID,:InciStateID,:DefinitionID,
+        :CreateTime,:ChangeBy,:ChangeTime,:Class,:ClassID,:ConfigItemID,:CreateBy,:CreateTime,
+        :CurDeplState,:CurDeplStateID,:CurDeplStateType,:CurInciState,:CurInciStateID,:CurInciStateType,
+        :DeplState,:DeplStateType,:InciState,:InciStateType,:LastVersionID,:Number,:VersionID)
+      xml_attributes.each do |key,value|
+        updated_attributes = updated_attributes.except(key)
+      end
+      data = updated_attributes
+      params = "Object=ConfigItemObject&Method=VersionAdd&Data=#{data}"
+      params = { :object => 'ConfigItemObject', :method => 'VersionAdd', :data => data }
+      a = self.class.connect(params)
+      new_version_id = a.first
+      params2 = "Object=ConfigItemObject&Method=VersionConfigItemIDGet&Data={\"VersionID\":\"#{new_version_id}\"}"
+      data2 = { 'VersionID' => new_version_id }
+      params2 = { :object => 'ConfigItemObject', :method => 'VersionConfigItemIDGet', :data => data2 }
+      b = self.class.connect(params2)
+      config_item = self.class.find(b.first)
+      attributes = config_item.attributes
+      attributes.each do |key,value|
+        instance_variable_set "@#{key.to_s}", value
+      end
+      config_item
+    end
+    
+    def self.from_otrs_xml(xml)
+      xml = xml.first[1].flatten[1][1].except("TagKey")
+      data = {}
+      xml.each do |key,value|
+        xml[key].delete(xml[key][0])
+        count = xml[key].count
+        if count == 1
+          data[key] = value[count - 1]["Content"]
+          count2 = value[count -1].except("Content","TagKey").count
+          if count2 >= 1
+            value[count - 1].except("Content","TagKey").each do |key2,value2|
+              value2.delete(value2[0])
+              data["#{key}__#{key2}"] = value2[0]["Content"]
+            end
+          end
+        else
+          while count != 0
+            data["#{key}__0#{count - 1}"] = value[count - 1]["Content"]
+            count3 = value[count - 1].except("TagKey").count
+            if count3 > 1
+              value[count - 1].except("Content","TagKey").each do |key3,value3|
+                value3.delete(value3[0])
+                count4 = value3.count
+                if count4 > 1
+                  while count4 != 0
+                    unless value3[count4 - 1]["Content"].nil?
+                      data["#{key}__0#{count - 1}__#{key3}__0#{count4 - 1}"] = value3[count4 - 1]["Content"]
+                    end
+                    count4 = count4 - 1
+                  end
+                  
+                else
+                  data["#{key}__0#{count - 1}__#{key3}"] = value3[0]["Content"]
+                end
+              end
+            end
+            count = count - 1
+          end
+        end
+      end
+      data
+    end
+
+    def self.lookup(id)
+      data = { 'ConfigItemNumber' => id }
+      params = { :object => 'ITSMConfigItemObject', :method => 'ConfigItemLookup', :data => data }
+      connect(params).first
+    end
+    
+    def self.find(id)
+      data = { 'ConfigItemID' => id }
+      params = { :object => 'ConfigItemObject', :method => 'ConfigItemGet', :data => data }
+      a = connect(params).first
+      class_id = a["ClassID"]
+      version_id = a["LastVersionID"]
+      data2 = { 'ClassID' => class_id, 'VersionID' => version_id }
+      params2 = { :object => 'ConfigItemObject', :method => '_XMLVersionGet', :data => data2 }
+      b = connect(params2)
+      b = self.from_otrs_xml(b)
+      data3 = { 'ConfigItemID' => id, 'XMLDataGet' => 0 }
+      params3 = { :object => 'ConfigItemObject', :method => 'VersionGet', :data => data3 }
+      c = connect(params3).first
+      self.new(a.merge(c).merge(b))
+    end
+    
+  end
+end

data/lib/otrs_connector/otrs/general_catalog.rb

@@ -0,0 +1,15 @@
+module OtrsConnector
+  class OTRS::GeneralCatalog < OTRS
+    
+    def self.find(id)
+      data = { 'ItemID' => id }
+      params = { :object => 'GeneralCatalogObject', :method => 'ItemGet', :data => data }
+      a = connect(params)
+      unless a.first.nil?
+        a = a.first.except('Class') ## Class field is causing issues in Rails
+      end
+      self.new(a)
+    end
+    
+  end
+end

data/lib/otrs_connector/otrs/group.rb

@@ -0,0 +1,34 @@
+module OtrsConnector
+  class OTRS::Group < OTRS
+
+    def self.find(id)
+      data = { 'ID' => id }
+      params = { :object => 'UserObject', :method => 'GroupGet', :data => data }
+      a = Hash[*connect(params)]
+        if a.empty? == false
+          self.new(a.symbolize_keys)
+        else
+          raise "ERROR::NoSuchID #{id}"
+        end
+    end
+
+    def self.where(attributes, only_ids = false)
+      tmp = {}
+      attributes.each do |key,value|
+        tmp[key.to_s.camelize.to_sym] = value
+      end
+      attributes = tmp
+      data = attributes
+      params = { :object => 'GroupObject', :method => 'GroupMemberList', :data => data }
+      a = connect(params)
+      a = Hash[*a]
+      return a.keys if only_ids
+      results = []
+      a.each do |key, value|
+       results << find(key)
+      end
+      results
+    end
+      
+  end
+end

data/lib/otrs_connector/otrs/link.rb

@@ -0,0 +1,62 @@
+module OtrsConnector
+  class OTRS::Link < OTRS
+    
+    def self.create(attributes)
+      attributes["State"] ||= 'Valid'
+      params = { :object => 'LinkObject', :method => 'LinkAdd', :data => attributes }
+      a = connect(params)
+      if a.first == "1"
+        return self
+      else
+        nil
+      end
+    end
+
+    def self.where_with_data(attributes)
+      attributes["State"] ||= 'Valid'
+      attributes["Object"] ||= "ITSMConfigItem"
+      params = { :object => 'LinkObject', :method => 'LinkListWithData', :data => attributes }
+      a = connect(params).collect do |item| 
+        next if item.blank?
+        OTRS::Ticket.new(item['Ticket']['RelevantTo']['Source'].values.first.symbolize_keys) rescue nil
+      end.compact
+    end
+    
+    def self.where(attributes)
+      # Returns list of link objects as Source => Target
+      # Haven't decided if I want this to return the link object or what is being linked to
+      attributes[:state] ||= 'Valid'
+      tmp = {}
+      attributes.each do |key,value|
+        tmp[key.to_s.camelize.to_sym] = value
+      end
+      data = tmp
+      params = { :object => 'LinkObject', :method => 'LinkKeyList', :data => data }
+      a = connect(params)
+      a = Hash[*a]
+      b = []
+      a.each do |key,value|
+        c = {}
+        c[:key2] = "#{key}"
+        c[:object2] = tmp[:Object2]
+        c[:object1] = tmp[:Object1]
+        c[:key1] = tmp[:Key1]
+        b << self.new(c)
+      end
+      b
+    end
+    
+    def where(attributes)
+      self.class.where(attributes)
+    end
+
+    def destroy
+      @type ||= 'Normal'
+      data = { 'Object1' => @object1, :key1 => @key1, :object2 => @object2, key2 => @key2, :type => @type }
+      #params = "Object=LinkObject&Method=LinkDelete&Data={\"Object1\":\"#{@object1}\",\"Key1\":\"#{@key1}\",\"Object2\":\"#{@object2}\",\"Key2\":\"#{@key2}\",\"Type\":\"#{@type}\"}"
+      params = { :object => 'LinkObject', :method => 'LinkDelete', :data => data }
+      a = connect(params)
+    end
+
+  end
+end

data/lib/otrs_connector/otrs/service.rb

@@ -0,0 +1,78 @@
+module OtrsConnector
+  class OTRS::Service < OTRS
+    
+    def self.find(id)
+      #params = "Object=ServiceObject&Method=ServiceGet&Data={\"ServiceID\":\"#{id}\",\"UserID\":\"1\"}"
+      data = { 'ServiceID' => id, 'UserID' => 1 }
+      params = { :object => 'ServiceObject', :method => 'ServiceGet', :data => data }
+      a = Hash[*connect(params)]
+        if a.empty? == false
+          self.new(a.symbolize_keys)
+        else
+          raise "ERROR::NoSuchID #{id}"
+        end
+    end
+    
+    def create(attributes)
+      attributes[:valid_id] ||= 1
+      attributes[:user_id] ||= 1
+      attributes[:type_id] ||= 1
+      attributes[:criticality_id] ||= 3
+      tmp = {}
+      attributes.each do |key,value|
+        if key == :user_id
+          tmp[:UserID] = value
+        end
+        if key == :valid_id
+          tmp[:ValidID] = value
+        end
+        if key == :type_id
+          tmp[:TypeID] = value
+        end
+        if key == :criticality_id
+          tmp[:CriticalityID] = value
+        end
+        if key == :parent_id
+          tmp[:ParentID] = value
+        end
+        if key != :user_id or key != :valid_id or key != :type_id or key != :crticality_id or key != :parent_id
+          tmp[key.to_s.camelize.to_sym] = value
+        end
+      end
+      attributes = tmp
+      data = attributes
+      #params = "Object=ServiceObject&Method=ServiceAdd&Data=#{data}"
+      params = { :object => 'ServiceObject', :method => 'ServiceAdd', :data => data }
+      a = connect(params)
+      service_id = a.first
+      unless service_id.nil?
+        self.class.find(service_id)
+      else
+        raise "Could not create service"
+      end
+      service = self.class.find(service_id)
+      service.attributes.each do |key,value|
+        instance_variable_set "@#{key.to_s}", value
+      end
+      service
+    end
+
+    def self.where(attributes)
+      tmp = {}
+      attributes.each do |key,value|
+        tmp[key.to_s.camelize.to_sym] = value
+      end
+      attributes = tmp
+      data = attributes
+      #params = "Object=ServiceObject&Method=ServiceSearch&Data=#{data}"
+      params = { :object => 'ServiceObject', :method => 'ServiceSearch', :data => data }
+      a = connect(params)
+      results = []
+      a.each do |s|
+       results << find(s)
+      end
+      results
+    end
+      
+  end
+end

data/lib/otrs_connector/otrs/ticket/article.rb

@@ -0,0 +1,43 @@
+module OtrsConnector
+  class OTRS::Ticket::Article < OTRS::Ticket
+
+    def self.simple_create!(data)
+      params = { :object => 'TicketObject', :method => 'ArticleCreate', :data => data }
+      a = connect(params)
+      a.first.nil? ? nil : a
+    end
+    
+    def create(attributes)
+      data = { 'TicketID' => attributes[:ticket_id], 'From' => attributes[:email], 'Subject' => attributes[:title], 'Body' => attributes[:body] }
+      data['ArticleType'] ||= 'email-external'
+      data['UserID'] ||= 1
+      data['SenderType'] ||= 'agent'
+      data['HistoryType'] ||= 'NewTicket'
+      data['HistoryComment'] ||= ' '
+      data['ContentType'] ||= 'text/plain'
+      params = { :object => 'TicketObject', :method => 'ArticleCreate', :data => data }
+      a = connect(params)
+      if a.first.nil? then nil else a end
+    end
+    
+    def self.find(id)
+      data = { 'ArticleID' => id, 'UserID' => 1 }
+      params = { :object => 'TicketObject', :method => 'ArticleGet', :data => data }
+      a = connect(params)
+      a = Hash[*a].symbolize_keys
+      self.new(a)
+    end
+    
+    def self.where(ticket_id)
+      data = { 'TicketID' => ticket_id }
+      params = { :object => 'TicketObject', :method => 'ArticleIndex', :data => data }
+      a = connect(params)
+      b = []
+      a.each do |c|
+        b << find(c)
+      end
+      b
+    end
+
+  end
+end

data/lib/otrs_connector/otrs/ticket/state.rb

@@ -0,0 +1,29 @@
+module OtrsConnector
+  class OTRS::Ticket::State < OTRS::Ticket
+    
+    def self.all
+      data = { 'UserID' => 1 }
+      #params = 'Object=StateObject&Method=StateList&Data={"UserID":"1"}'
+      params = { :object => 'StateObject', :method => 'StateList', :data => data }
+      a = connect(params)
+      a = Hash[*a]
+      b = []
+      a.each do |key,value|
+        c = {}
+        c[key] = value
+        b << c
+      end
+      c = []
+      b.each do |d|
+        d.each do |key,value|
+          tmp = {}
+          tmp[:id] = key
+          tmp[:name] = value
+          c << new(tmp)
+        end
+      end
+      c
+    end
+    
+  end
+end

data/lib/otrs_connector/otrs/ticket/ticket_queue.rb

@@ -0,0 +1,29 @@
+module OtrsConnector
+  class OTRS::Ticket::TicketQueue < OTRS::Ticket # Namespace conflict with OTRS::Ticket::Queue
+    
+    def self.all
+      data = { 'UserID' => 1 }
+      #params = 'Object=QueueObject&Method=QueueList&Data={"UserID":"1"}'
+      params = { :object => 'QueueObject', :method => 'QueueList', :data => data }
+      a = connect(params)
+      a = Hash[*a]
+      b = []
+      a.each do |key,value|
+        c = {}
+        c[key] = value
+        b << c
+      end
+      c = []
+      b.each do |d|
+        d.each do |key,value|
+          tmp = {}
+          tmp[:id] = key
+          tmp[:name] = value
+          c << new(tmp)
+        end
+      end
+      c
+    end
+    
+  end
+end

data/lib/otrs_connector/otrs/ticket/type.rb

@@ -0,0 +1,29 @@
+module OtrsConnector
+  class OTRS::Ticket::Type < OTRS::Ticket
+    
+    def self.all
+      data = { 'UserID' => 1 }
+      #params = 'Object=TicketObject&Method=TicketTypeList&Data={"UserID":"1"}'
+      params = { :object => 'TicketObject', :method => 'TicketTypeList', :data => data }
+      a = connect(params)
+      a = Hash[*a]
+      b = []
+      a.each do |key,value|
+        c = {}
+        c[key] = value
+        b << c
+      end
+      c = []
+      b.each do |d|
+        d.each do |key,value|
+          tmp = {}
+          tmp[:id] = key
+          tmp[:name] = value
+          c << new(tmp)
+        end
+      end
+      c
+    end
+    
+  end
+end

data/lib/otrs_connector/otrs/ticket.rb

@@ -0,0 +1,148 @@
+module OtrsConnector
+  class OTRS::Ticket < OTRS
+    # Validations aren't working
+    validates_presence_of :title
+    validates_presence_of :body
+    validates_presence_of :email
+
+    def self.free_text_get(type, user_id, ticket_id = nil)
+      data = { 'Type' => type, 'UserID' => user_id }
+      data.merge!({'TicketID' => ticket_id}) if ticket_id
+      params = { :object => 'TicketObject', :method => 'TicketFreeTextGet', :data => data }
+      connect(params).first
+    end
+
+    def self.free_text_set(user_id, ticket_id, key, value, counter)
+      data = { 
+        "Counter" => counter,
+        "Key" => key,
+        "Value" => value,
+        "UserID" => user_id,
+        "TicketID" => ticket_id
+      }
+
+      params = { :object => 'TicketObject', :method => 'TicketFreeTextSet', :data => data }
+      connect(params).first
+    end
+    
+    def self.ticket_number_lookup(ticket_id)
+      data = { 'TicketID' => ticket_id, 'UserID' => 1 }
+      #params = "Object=TicketObject&Method=TicketNumberLookup&Data={\"TicketID\":\"#{ticket_id}\",\"UserID\":\"1\"}"
+      params = { :object => 'TicketObject', :method => 'TicketNumberLookup', :data => data }
+      connect(params)
+    end
+
+    def self.simple_create!(data)
+      params = { :object => 'TicketObject', :method => 'TicketCreate', :data => data }
+      a = connect(params)
+      ticket_id = a.first
+      self.find(ticket_id)
+    end
+    
+    def create(attributes)
+      attributes[:otrs_type] ||= 'Incident'
+      attributes[:state] ||= 'new'
+      attributes[:queue] ||= 'Service Desk'
+      attributes[:lock] ||= 'unlock'
+      attributes[:priority] ||= '3 normal'
+      attributes[:user_id] ||= '1'
+      attributes[:owner_id] ||= attributes[:user_id]
+      tmp = {}
+      attributes.each do |key,value|
+        if key == :otrs_type
+          tmp[:Type] = value
+        end
+        if key == :user_id
+          tmp[:UserID] = value
+        end
+        if key == :owner_id
+          tmp[:OwnerID] = value
+        end
+        if key == :customer_id
+          tmp[:CustomerID] = value
+        end
+        if key != :user_id or key != :owner_id or key != :customer_id
+          tmp[key.to_s.camelize.to_sym] = value
+        end
+
+      end
+      attributes = tmp
+      data = attributes
+      params = { :object => 'TicketObject', :method => 'TicketCreate', :data => data }
+      a = connect(params)
+      ticket_id = a.first
+      article = OTRS::Ticket::Article.new(
+        :ticket_id => ticket_id, 
+        :body => attributes[:Body], 
+        :email => attributes[:Email], 
+        :title => attributes[:Title])
+      if article.save
+        ticket = self.class.find(ticket_id)
+        attributes = ticket.attributes
+        attributes.each do |key,value|
+          instance_variable_set "@#{key.to_s}", value
+        end
+        ticket
+      else
+        ticket.destroy
+        raise 'Could not create ticket'
+      end
+    end
+    
+    def destroy
+      id = @ticket_id
+      if self.class.find(id)
+        data = { 'TicketID' => id, 'UserID' => 1 }
+        params = { :object => 'TicketObject', :method => 'TicketDelete', :data => data }
+        connect(params)
+        "Ticket ID: #{id} deleted"
+      else
+        raise 'Error:NoSuchID'
+      end
+    end
+    
+    def self.find(id)
+      data = { 'TicketID' => id, 'UserID' => 1 }
+      #params = "Object=TicketObject&Method=TicketGet&Data={\"TicketID\":\"#{id}\",\"UserID\":\"1\"}"
+      params = { :object => 'TicketObject', :method => 'TicketGet', :data => data }
+      a = Hash[*connect(params)]
+      if a.empty? == false
+        self.new(a.symbolize_keys)
+      else
+        raise "ERROR::NoSuchID #{id}"
+      end
+    end
+    
+    
+    def self.where(attributes)
+      data = attributes
+      params = { :object => 'TicketObject', :method => 'TicketSearch', :data => data }
+      a = connect(params)
+      b = Hash[*a]          # Converts array to hash where key = TicketID and value = TicketNumber, which is what gets returned by OTRS
+      c = []
+      b.each do |key,value| # Get just the ID values so we can perform a find on them
+        c << key
+      end
+      results = []
+      c.each do |t|
+        results << find(t)  #Add find results to array
+      end
+      results   # Return array of hashes.  Each hash is one ticket record
+    end
+    
+    def where(attributes)
+      self.class.where(attributes)
+    end
+
+    def self.delete_by_id(id)
+      if find(id)
+        data = { 'TicketID' => id, 'UserID' => 1 }
+        params = { :object => 'TicketObject', :method => 'TicketDelete', :data => data }
+        connect(params)
+        "Ticket ID: #{id} deleted"
+      else
+        raise 'Error:NoSuchID'
+      end
+    end
+  end
+end