teamforge 0.0.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 CollabNet, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,18 @@
+= TeamForge Ruby SDK
+
+* TeamForge Version 6.1.1
+* SDK Version 0.0.2
+
+== Description
+
+This is a Ruby wrapper for interacting with the CollabNet TeamForge SOAP WebService.  
+
+
+== Install
+
+* sudo gem install teamforge
+
+== Copyright
+Author::	Patrick Wolf (mailto:pwolf@collab.net)
+Copyright::	2013 CollabNet, Inc., 
+License::	 MIT license

data/lib/teamforge/ctfsoap.rb

@@ -0,0 +1,189 @@
+module TeamForge
+    
+    # Every call sent to the TeamForge server goes through two methods: request and parse_response. This makes it easier to normalize how messages are sent and received
+    # and it also makes it easier to troubleshoot because there is one place to trap messages to and from the server.
+    # The request method can be called on its own with no other part of this SDK wrapper if the proper paramters are passed to it. 
+    # Everything else in the gem package is provided as a placeholder for the CTF Server endpoint, a set of CTF Object types, and convenience methods to generate the proper parameters for each method.
+    #  E.g. CTF.request(method, message, endpoint, response, proxy=nil)
+    # Each request to the CTF server expects the following information:
+    #   method: This is the function call that the server is expected to complete. A symbol is expected. E.g. :login
+    #   message: This is the body of the soap call to the server. The expected value is a hash. If a soap object is specified it should be converted to a hash. 
+    #     All objects provided in this SDK include a to_h function to convert all instance variables into a nested hash with the object type.
+    #     E.g. {:userName=>username, :password=>password, {:order! => [:userName, :password]} }
+    #     The order! key tells the message the parameter order expected by the server. CTF is picky about parameter order.
+    #   endpoint: The URL of the specific soap endpoint for this method. Each of the different CTF Web services has its own endpoint. This is specified in each function call within this SDK wrapper.
+    #     E.g. "http://localhost:8080/ce-soap60/services/TrackerApp"
+    #   response: The response message name that is expected from a successful call to the CTF server.  A symbol is expected
+    #     E.g. :loginResponse
+    #   proxy: If a proxy server is being used to connect to the the CTF server it should be specified. It can be left blank.
+    def self.request(req_msg, server=nil, proxy=nil)
+      return unless req_msg.kind_of? Struct
+      
+      server ||= @server
+      
+      if server.nil?
+        raise(TeamForgeError, "No TeamForge server specified")
+      else
+        @server = format_url(server)
+      end
+      
+      proxy ||= @proxy
+      
+      @endpoint, method = req_msg.class.to_s.split("::").pop(2)
+      @endpoint == "TeamForge" ? @endpoint = "CollabNet" : @endpoint
+      
+      method = "#{method.slice!(0).downcase}#{method}".to_sym 
+      
+      response_msg = "#{method}Response".to_sym
+      return_msg = "#{method}Return".to_sym
+        
+      
+      fq_path = @server + SERVICE_PATH + @endpoint
+
+  
+      # The client from Savon is instantiated with the proper namespace, the endpoint for the request, and SSL verification (from HTTPI) turned off
+      client = Savon::Client.new {wsdl.namespace = SERVICE_NAMESPACE; wsdl.endpoint = fq_path; http.auth.ssl.verify_mode= :none }
+
+      # proxy support in case CTF needs to be accessed through a proxy
+      if proxy
+        client.http.proxy = @proxy
+      end
+
+      
+      unless req_msg.respond_to? :empty
+        message = Hash[req_msg.each_pair.to_a]
+
+        # if a TeamForge Struct was sent to the function it has to be converted to a hash first to be processed by Savon 
+        # Luckily there is an easy method to convert a Struct to a Hash
+        message.each do |key, value|
+          message[key] = rep_blank_with_nil(value)
+        end
+      end
+             
+      message[:order!] = req_msg.members
+
+      begin
+        # This is the only place that the Savon::Client is currently used. It creates a SOAP requests with the required namespaces, headers, and the SOAP message that was sent to the request method.
+        # The response message from the CTF server is a SOAP method.  
+        ctfresponse = client.request(method) do
+          soap.namespaces["xmlns:tns1"] = TYPE_NAMESPACE  
+          soap.namespaces["xmlns:impl"] = SERVICE_NAMESPACE 
+          soap.namespaces["xmlns:soapenc"] = SOAP_NAMESPACE
+          soap.body = message
+        end
+        # Return any error messages in a return hash. This error might be SOAP, HTTPI, or generic error. Each method checks for presense of fault but does not raise runtime error. 
+        # Raising runtime exceptions is left to the calling program
+      rescue Exception => e  
+        raise(TeamForgeError, e.message)
+      end
+      
+      # if there are no errors our call to CTF was successful and we need to parse the response
+      # Savon does not handle MultiRef responses so we get a Nokogiri XML document and send that to our custom parser
+      # The parser must also be told what CTF return message that is expected
+      @response_doc = ctfresponse.doc
+      
+      parse_response(response_msg)[return_msg]
+
+    end
+
+    # A very basic Nokogiri parser. This function requires two parameters:
+    #   property: This is the return message that the specific CTF method is expected to return
+    #     E.g.  :loginResponse
+    #   response: This parameter is expected to be a Nokogiri document.
+    # This method returns a hash. The key for hash will be the element name of the return and the value will be the element value.
+    # If the element has an "href" attribute the return value is a complex type and must be parsed as a complex type.
+    # If DataRows are present then the response is an array of complexTypes and an array must be created to hold these datarows.
+    # If it is a complexType this function will return an object of the type specified. 
+    #   E.g. UserSoapDO
+    def self.parse_response(doc_node)
+      return_msg = {}
+      @response_doc.xpath("//#{doc_node.to_s}").children.each do |child|
+        
+        href = child.attribute("href").to_s.gsub("#","")
+        
+        unless href.empty?
+          multiref = @response_doc.xpath("//multiRef[@id='#{href}']")
+          
+         if multiref.children.first.name == "dataRows"
+           datarows = []
+           multiref.children.children.each do |datarow|
+             data_href = datarow.attribute("href").to_s.gsub("#","")
+             datarows.push(create_struct(@response_doc.xpath("//multiRef[@id='#{data_href}']")))
+           end
+           return_msg[child.name.to_sym] = datarows
+         else
+           return_msg[child.name.to_sym] = create_struct(multiref)
+         end
+       else
+         return_msg[child.name.to_sym] = child.text
+       end
+     end
+     return return_msg
+   end
+          
+    # Takes a Nokogiri node and parses it into the object type specified
+    # The return type is a Ruby object 
+    def self.create_struct(node)
+      
+      @endpoint == "CollabNet" ? ctfapp="TeamForge" : ctfapp="TeamForge::#{@endpoint}"
+      attributes = {}
+    
+      type = node.attribute("type").to_s.split(":")[1]
+      
+      new_struct = eval("#{ctfapp}::#{type}.new")
+      
+      node.children.each do |element| 
+        
+        el_type = element.attribute("type").to_s.split(":")[1].to_s.downcase.to_sym
+        node_href = element.attribute("href").to_s.gsub("#","")
+        
+        element.name = element.name.snakecase
+        
+        unless node_href.empty?
+          new_struct[element.name] = create_struct(@response_doc.xpath("//multiRef[@id='#{node_href}']"))
+        else
+          if el_type == :array
+            unless element.child.nil?
+              new_struct[element.name.to_sym] = {element.name.to_sym => element.element_children.map {|chld| chld.text.to_s }, :attributes! => { element.child.name.to_sym => {'xsi:type' => element.child.attribute("type").to_s}}}
+            end
+            attributes[element.name.to_sym] = {'soapenc:arrayType'=> element.attribute("arrayType").to_s, 'xsi:type' => element.attribute("type").to_s}
+          else 
+            new_struct[element.name] = element.text.to_s
+            attributes[element.name.to_sym] = {'xsi:type' => element.attribute("type").to_s}
+          end
+        end
+        
+      end
+      
+      new_struct[:attributes!] = attributes
+    
+      return new_struct
+    end
+    
+    def self.rep_blank_with_nil(value)
+      
+      if value.kind_of? Struct
+        struct_param = Hash[value.each_pair.to_a]
+        
+        struct_param.each do |k, v| 
+          struct_param[k] = rep_blank_with_nil(v)
+        end
+        
+        value = struct_param
+        
+      else
+        unless value.nil?
+          if value.blank?
+            value = nil
+          end #if
+        end #unless
+      end #if
+      return value
+    end    #def
+    
+    
+    
+  #end
+    
+end
+  

data/lib/teamforge/services/categorizationapp.rb

@@ -0,0 +1,91 @@
+
+module TeamForge
+	module CategorizationApp
+
+######################
+#  CategorizationApp Messages
+######################
+		AddProjectToCategory = Struct.new(:session_id, :project_id, :category_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		CreateCategory = Struct.new(:session_id, :parent_id, :title, :description) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		DeleteCategory = Struct.new(:session_id, :category_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		GetAllCategories = Struct.new(:session_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		GetCategoryData = Struct.new(:session_id, :category_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		GetCategoryProjects = Struct.new(:session_id, :category_id, :include_subcategories) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		GetProjectCategories = Struct.new(:session_id, :project_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		GetRootCategoryData = Struct.new(:session_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		GetSubcategories = Struct.new(:session_id, :category_id, :recursive) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		GetUncategorizedProjects = Struct.new(:session_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		IsCategorizationEnabled = Struct.new(:session_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		MoveCategory = Struct.new(:session_id, :category_id, :dst_category_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		RemoveProjectFromCategory = Struct.new(:session_id, :project_id, :category_id) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+		SetCategoryData = Struct.new(:session_id, :category_data) do 
+    		  def send (server=nil, proxy=nil) 
+    		    TeamForge.request(self, server, proxy) 
+    	    end 
+        end
+
+
+######################
+#  CategorizationApp Types
+######################
+
+		CategorySoapDO = Struct.new(:created_by,:created_date,:description,:id,:last_modified_by,:last_modified_date,:parent_folder_id,:path,:project_id,:title,:version, :attributes!)
+		CategorySoapRow = Struct.new(:created_by,:created_on,:description,:id,:last_modified_by,:last_modified_on,:parent_folder_id,:path,:project_id,:title, :attributes!)
+		ProjectSoapRow = Struct.new(:date_created,:description,:hierarchy_path,:id,:locked,:parent_project_id,:path,:title, :attributes!)
+
+	end # module CategorizationApp
+
+
+end # module TeamForge