mingle4r 0.3.0

data/lib/mingle4r/api/v2/card/attachment.rb

@@ -0,0 +1,51 @@
+module Mingle4r
+  class API
+    class V2
+      class Card
+        class Attachment
+          module InstanceMethods
+            # downloads the attachment. It an additional file path is given it saves it at the 
+            # given path. The given path should be writable
+            def download(file_name = nil)
+              collection_uri = self.class.site
+              rel_down_url = self.url
+              base_url = "#{collection_uri.scheme}://#{collection_uri.host}:#{collection_uri.port}/"
+              down_uri = URI.join(base_url, rel_down_url)
+              req = Net::HTTP::Get.new(down_uri.path)
+              req.basic_auth self.class.user, self.class.password
+              begin
+                res = Net::HTTP.start(down_uri.host, down_uri.port) { |http| http.request(req) }
+                file_name ||= self.file_name()
+                File.open(file_name, 'w') { |f| f.print(res.body) }
+              rescue Exception => e
+                e.message
+              end
+            end # download
+
+            # alias for file_name
+            def name
+              file_name()
+            end
+
+            # so that active resource tries to find by proper id
+            def id
+              name()
+            end
+
+            # This method had to be overriden. 
+            # normal active resource destroy doesn't work as mingle site for deleting attachments doesn't end with .xml.
+            def destroy
+              connection = self.send(:connection)
+              # deletes the attachment by removing .xml at the end
+              connection.delete(self.send(:element_path).gsub(/\.xml\z/, ''))
+            end
+            alias_method :delete, :destroy
+          end #module InstanceMethods
+
+          extend Mingle4r::CommonClassMethods
+
+        end # class Attachment
+      end # class Card
+    end # class V2
+  end # class API
+end # module Mingle4r

data/lib/mingle4r/api/v2/card/comment.rb

@@ -0,0 +1,16 @@
+module Mingle4r
+  class API
+    class V2
+      class Card
+        class Comment
+          module InstanceMethods
+            def to_s
+              attributes['content']
+            end
+          end
+          extend Mingle4r::CommonClassMethods
+        end
+      end
+    end
+  end
+end

data/lib/mingle4r/api/v2/card/transition.rb

@@ -0,0 +1,52 @@
+module Mingle4r
+  class API
+    class V2
+      class Card
+        class Transition
+          extend Mingle4r::CommonClassMethods
+
+          module InstanceMethods
+            def execute(args = {})
+              args.symbolize_keys!
+              trans_exec_xml = convert_to_xml(args)
+              # set_transition_execution_attributes
+              conn = self.class.connection
+              url_path =URI.parse(transition_execution_url()).path 
+              conn.post(url_path, trans_exec_xml, self.class.headers)
+            end
+
+            private
+            def convert_to_xml(args)
+              hash = create_transition_exec_hash(args)
+              xmlize_trans_exec(hash)
+            end
+            
+            def create_transition_exec_hash(args)
+              transition_hash = {}
+              transition_hash['card'] = (args.delete(:card) || associated_card_number).to_i
+              args.delete(:name) || args.delete(:transition)
+              
+              comment = args.delete(:comment)
+              transition_hash['comment'] = comment if comment
+              properties = []
+              args.each do |name, value|
+                property = {'name' => name.to_s, 'value' => value}
+                properties.push(property)
+              end
+              transition_hash['properties'] = properties unless properties.empty?
+              transition_hash
+            end
+            
+            def xmlize_trans_exec(hash)
+              hash.to_xml(:root => 'transition_execution', :dasherize => false)
+            end
+            
+            def associated_card_number
+              File.basename(self.class.site.to_s).to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mingle4r/api/v2/card.rb

@@ -0,0 +1,157 @@
+module Mingle4r
+  class API
+    class V2
+      class Card  
+        extend Mingle4r::CommonClassMethods
+        
+        # overwrite the default find in CommonClassMethods
+        def self.find(*args)
+          scope = args.slice!(0)
+          options = args.slice!(0) || {}
+          @resource_class.find_without_pagination(scope, options)
+        end
+        
+        module ClassMethods
+          def find_without_pagination(*args)
+            scope   = args.slice!(0)
+            options = args.slice!(0) || {}
+            options[:params] ||= {}
+            options[:params].merge!({:page => 'all'})
+            # call ActiveResource::Base::find with proper options
+            find(scope, options)
+          end
+
+          # applies an mql filter on card types. Look at https://mingle05.thoughtworks.com/help/mql_reference.html
+          # for reference
+          def apply_filter(filter_string)
+            find_without_pagination(:all, :params => {'filters[mql]'.to_sym => filter_string})
+          end
+        end
+
+        module InstanceMethods
+          # so that active resource tries to find by number
+          def id
+            number()
+          end
+
+          def attachments(refresh = false)
+            return @attachments if(!refresh && @attachments)
+            attachment_site           = File.join(self.class.site.to_s, "cards/#{self.number()}").to_s
+            Card::Attachment.site     = attachment_site
+            Card::Attachment.user     = self.class.user
+            Card::Attachment.password = self.class.password
+            attachment_class          = Card::Attachment.send(:create_resource_class)
+            @attachments              = attachment_class.find(:all)
+          end
+          
+          def comments(refresh = false)
+            return @comments if(!refresh && @comments)
+            set_comment_class_attributes
+            @comments = Card::Comment.find(:all)
+          end
+          
+          def transitions(refresh = false)
+            return @transitions if(!refresh && @transitions)
+            set_transition_class_attributes
+            @transitions = Card::Transition.find(:all)
+          end
+          
+          def murmurs(refresh = false)
+            return @murmurs if(!refresh && @murmurs)
+            set_murmur_class_attributes
+            @murmurs = Murmur.find(:all)
+          end
+          
+          def upload_attachment(file_path)
+            attachment_uri   = URI.parse(File.join(self.class.site.to_s, "cards/#{self.number()}/attachments.xml"))
+            http             = Net::HTTP.new(attachment_uri.host, attachment_uri.port)
+            http.use_ssl     = attachment_uri.is_a?(URI::HTTPS)
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+            basic_encode     = 'Basic ' + ["#{self.class.user}:#{self.class.password}"].pack('m').delete("\r\n")
+
+            post_headers = {
+              'Authorization' => basic_encode,
+              'Content-Type'  => 'multipart/form-data; boundary=----------XnJLe9ZIbbGUYtzPQJ16u1'
+            }
+
+            file_content = IO.read(file_path)
+
+            post_body = <<EOS
+------------XnJLe9ZIbbGUYtzPQJ16u1\r
+Content-Disposition: form-data; name="file"; filename="#{File.basename(file_path)}"\r
+Content-Type: application/octet-stream\r
+Content-Length: #{file_content.size}\r
+\r
+#{file_content}\r
+------------XnJLe9ZIbbGUYtzPQJ16u1--\r
+EOS
+        
+            http.post(attachment_uri.path, post_body, post_headers)
+          end
+          
+          def add_comment(str)
+            set_comment_class_attributes
+            comment = Card::Comment.new(:content => str.to_s)
+            comment.save
+          end
+          
+          def execute_transition(args)
+            trans_name = args.symbolize_keys[:name]
+            transition = transitions.detect { |t| t.name ==  trans_name}
+            transition.execute(args)
+          end
+          
+          # returns back the version of the card given. If an invalid version is given, the latest
+          # version is returned, takes a number or :next or :before
+          def at_version(version_no)
+            version_2_find = 0
+            case version_no
+            when :before
+              version_2_find = self.version.to_i - 1
+            when :next
+              version_2_find = self.version.to_i + 1
+            else
+              version_2_find = version_no.to_i
+            end
+            self.class.find(self.number, :params => {:version => version_2_find})
+          end
+          
+          # Gets and sets the value of a property. The property name given should be the same
+          # as the mingle property name. the value is optional
+          def property_value(name, val = nil)
+            property = properties.detect { |p| p.name == name }
+            val ? property.value = val : property.value
+          end
+      
+          # Gets the custom properties in the form of an array of hashes with the property names as keys and
+          # property values as the value
+          def custom_properties
+            properties.map { |p| {p.name => p.value} }
+          end
+          
+          private
+          def set_comment_class_attributes
+            comment_site           = File.join(self.class.site.to_s, "cards/#{self.number()}").to_s
+            Card::Comment.site     = comment_site
+            Card::Comment.user     = self.class.user
+            Card::Comment.password = self.class.password
+          end
+          
+          def set_transition_class_attributes
+            transition_site           = File.join(self.class.site.to_s, "cards/#{self.number()}").to_s
+            Card::Transition.site     = transition_site
+            Card::Transition.user     = self.class.user
+            Card::Transition.password = self.class.password
+          end
+          
+          def set_murmur_class_attributes
+            murmur_site = File.join(self.class.site.to_s, "cards/#{self.number()}").to_s
+            V2::Murmur.site = murmur_site
+            V2::Murmur.user = self.class.user
+            V2::Murmur.password = self.class.password
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mingle4r/api/v2/murmur.rb

@@ -0,0 +1,14 @@
+module Mingle4r
+  class API
+    class V2
+      class Murmur
+        extend Mingle4r::CommonClassMethods
+        module InstanceMethods
+          def to_s
+            author.name.to_s + ' - ' + body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mingle4r/api/v2/project.rb

@@ -0,0 +1,90 @@
+module Mingle4r
+  class API
+    class V2
+      class Project
+        module InstanceMethods
+          # returns the cards for the project. To hit the resource server without returning
+          # cached results pass true as an argument.
+          def cards(refresh = false)
+            return @cards if(!refresh && @cards_cached)
+            cards_site = File.join(self.class.site.to_s, "projects/#{self.identifier()}")
+            Card.site = cards_site
+            Card.user = self.class.user
+            Card.password = self.class.password
+            # @cards = Card.send(:create_resource_class).find_without_pagination(:all)
+            @cards = Card.find_without_pagination(:all)
+            @cards_cached = true
+            @cards
+          end
+
+          # returns the users for the project. To hit the resource server without returning
+          # cached results pass true as an argument.
+          def users(refresh = false)
+            return @users if(!refresh && @users_cached)
+            users_site = File.join(self.class.site.to_s, "projects/#{self.identifier()}")
+            User.site = users_site
+            User.user = self.class.user
+            User.password = self.class.password
+            User.element_name = nil # reset
+            user_class = User.send(:create_resource_class)
+            @users = user_class.find(:all)
+            @users_cached = true
+            @users
+          end
+
+          # returns the wikis for the project. To hit the resource server without returning
+          # cached results pass true as an argument.
+          def wikis(refresh = false)
+            return @wikis if(!refresh && @wikis_cached)
+            wiki_site = File.join(self.class.site.to_s, "projects/#{self.identifier()}")
+            Wiki.site = wiki_site
+            Wiki.user = self.class.user
+            Wiki.password = self.class.password
+            wiki_class = Wiki.send(:create_resource_class)
+            @wikis = wiki_class.find(:all)
+            @wikis_cached = true
+            @wikis
+          end
+
+          # returns the property definitions for the project. To hit the resource server
+          # pass true as an argument
+          def property_definitions(refresh = false)
+            return @prop_definitions if(!refresh && @prop_definitions_cached)
+            properties_site = File.join(self.class.site.to_s, "/projects/#{self.identifier}")
+            PropertyDefinition.site = properties_site
+            PropertyDefinition.user = self.class.user
+            PropertyDefinition.password = self.class.password
+            prop_defn_class = PropertyDefinition.send(:create_resource_class)
+            @prop_definitions = prop_defn_class.find(:all)
+            @prop_definitions_cached = true
+            @prop_definitions
+          end
+          
+          # returns the murmurs for the project. To hit the resource server without returning
+          # cached results pass true as an argument.
+          def murmurs(refresh = false)
+            return @murmurs if(!refresh && @murmurs)
+            murmur_site = File.join(self.class.site.to_s, "/projects/#{self.identifier}")
+            Murmur.site = murmurs_site
+            Murmur.user = self.class.user
+            Murmur.password = self.class.password
+            @murmurs = Murmur.find(:all)
+          end
+          
+          # posts a murmur
+          def post_murmur(str)
+            murmurs_site = File.join(self.class.site.to_s, "projects/#{self.identifier}")
+            Murmur.site = murmurs_site
+            Murmur.user = self.class.user
+            Murmur.password = self.class.password
+            
+            murmur = Murmur.new(:body => str.to_s)
+            murmur.save
+          end
+        end # module InstanceMethods
+    
+        extend Mingle4r::CommonClassMethods
+      end # class Project
+    end # class V1
+  end # class API
+end

data/lib/mingle4r/api/v2/property_definition.rb

@@ -0,0 +1,14 @@
+module Mingle4r
+  class API
+    class V2
+      class PropertyDefinition
+        extend Mingle4r::CommonClassMethods
+
+        def self.column_name_for(prop_name)
+          property_def = @resource_class.find(:all).detect { |prop| prop.name == prop_name }
+          property_def ? property_def.column_name : nil
+        end
+      end
+    end
+  end
+end

data/lib/mingle4r/api/v2/user.rb

@@ -0,0 +1,9 @@
+module Mingle4r
+  class API
+    class V2
+      class User
+        extend Mingle4r::CommonClassMethods
+      end
+    end
+  end
+end

data/lib/mingle4r/api/v2/wiki.rb

@@ -0,0 +1,12 @@
+module Mingle4r
+  class API
+    class V2
+      class Wiki
+        extend Mingle4r::CommonClassMethods
+      end
+    end
+  end
+end
+
+Mingle4r::API::V1::Wiki.collection_name = 'wiki'
+Mingle4r::API::V1::Wiki.element_name = 'page'

data/lib/mingle4r/api/v2.rb

@@ -0,0 +1,25 @@
+module Mingle4r
+  class API
+    class V2
+      def initialize(host_url)
+        @host_uri = URI.parse(host_url)
+      end
+      
+      def base_url
+        File.join(@host_uri.to_s, '/api/v2')
+      end
+      
+      def version
+        2
+      end
+      
+      def project_class
+        Project
+      end
+      
+      def user_class
+        User
+      end
+    end
+  end
+end

data/lib/mingle4r/api.rb

@@ -0,0 +1,31 @@
+require 'uri'
+require 'net/https'
+
+module Mingle4r
+  class API
+    class << self
+      def create(url)
+        @host_uri = URI.parse(url)
+        api_ver = mingle_version.to_i - 1
+        class_name = 'V' + api_ver.to_s
+        ver_class = send(:const_get, class_name.to_sym)
+        ver_class.new(url)
+      end
+      
+      def mingle_version
+        html  = mingle_about_page
+        match = html.match('<dd>Version</dd>\n.*<dt>([_\d]*)</dt>')
+        raise Exception, 'Not a proper mingle instance' unless match
+        @mingle_version = match[1].gsub('_','.').to_f
+      end
+
+      private
+      def mingle_about_page
+        http             = Net::HTTP.new(@host_uri.host, @host_uri.port)
+        http.use_ssl     = true if @host_uri.is_a?(URI::HTTPS)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl
+        http.get('/about').body
+      end
+    end
+  end # class API
+end