ticketmaster-teambox 0.1.0

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "ticketmaster", "0.5.6"
+gem "oauth2"
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+  gem "rspec", "= 1.2.9"
+end
+

data/Gemfile.lock

@@ -0,0 +1,52 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.7)
+      activesupport (= 3.0.7)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activeresource (3.0.7)
+      activemodel (= 3.0.7)
+      activesupport (= 3.0.7)
+    activesupport (3.0.7)
+    addressable (2.2.6)
+    builder (2.1.2)
+    faraday (0.6.1)
+      addressable (~> 2.2.4)
+      multipart-post (~> 1.1.0)
+      rack (< 2, >= 1.1.0)
+    git (1.2.5)
+    hashie (1.0.0)
+    i18n (0.5.0)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    multi_json (1.0.3)
+    multipart-post (1.1.1)
+    oauth2 (0.4.1)
+      faraday (~> 0.6.1)
+      multi_json (>= 0.0.5)
+    rack (1.3.0)
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (1.2.9)
+    ticketmaster (0.5.6)
+      activeresource
+      activeresource (>= 2.3.2)
+      activesupport
+      activesupport (>= 2.3.2)
+      hashie (= 1.0.0)
+      hashie
+      jeweler
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.1)
+  oauth2
+  rcov
+  rspec (= 1.2.9)
+  ticketmaster (= 0.5.6)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Hybridgroup
+
+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.md

@@ -0,0 +1,70 @@
+# ticketmaster-teambox
+
+This is a provider for [ticketmaster](http://ticketrb.com). It provides interoperability with [Teambox](http://www.teambox.com).
+
+# Usage and Examples
+
+First we have to instantiate a new ticketmaster instance:
+    teambox = TicketMaster.new(:teambox, {:username => "foo", :password => "bar", :client_id => "your_client_id", :client_secret => "your_client_secret"})
+
+If you do not pass in username, password, client id and client secret you won't get any information.
+
+== Finding Projects
+
+You can find your own projects by doing:
+
+    projects = teambox.projects # Will return all your projects
+    projects = teambox.projects([12345, 67890]) # You must use your projects identifier 
+    project = teambox.project(12345) # Also use project identifier in here
+	
+== Finding Tickets
+
+    tickets = project.tickets # All open issues
+    ticket = project.ticket(<ticket_number>)
+
+== Open Tickets
+    
+	ticket = project.ticket!({:name => "New ticket", :task_list_id => 23232})
+
+= Update a ticket
+	
+	ticket.name = "New ticket name"
+	ticket.save
+
+== Finding Comments
+  
+  comments = ticket.comments #All comments
+
+== Create Comments
+
+  comment = ticket.comment!(:body => "this is a new comment")
+
+## Requirements
+
+* rubygems (obviously)
+* ticketmaster gem (latest version preferred)
+* jeweler gem and bundler gem (only if you want to repackage and develop)
+* OAuth2 gem
+
+The ticketmaster gem and OAuth2 gem should automatically be installed during the installation of these gems if it is not already installed.
+
+## Other Notes
+
+Since this and the ticketmaster gem is still primarily a work-in-progress, minor changes may be incompatible with previous versions. Please be careful about using and updating this gem in production.
+
+If you see or find any issues, feel free to open up an issue report.
+
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2011 [Hybrid Group](http://hybridgroup.com). See LICENSE for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ticketmaster-teambox"
+  gem.homepage = "http://ticketrb.com"
+  gem.summary = %Q{Ticketmaster Provider for Teambox}
+  gem.description = %Q{Allows ticketmaster to interact with Teambox}
+  gem.email = "ana@hybridgroup.com"
+  gem.authors = ["Hybridgroup"]
+  gem.add_dependency "activesupport", ">= 3.0.4"
+  gem.add_dependency "activeresource", ">= 3.0.4"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ticketmaster-teambox #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/provider/comment.rb

@@ -0,0 +1,63 @@
+module TicketMaster::Provider
+  module Teambox
+    # The comment class for ticketmaster-teambox
+    #
+    # Do any mapping between Ticketmaster and your system's comment model here
+    # versions of the ticket.
+    #
+    class Comment < TicketMaster::Provider::Base::Comment
+      API = TeamboxAPI::Comment # The class to access the api's comments
+      # declare needed overloaded methods here
+      #
+      def initialize(*object)
+        if object.first
+          object = object.first
+          @system_data = {:client => object}
+          unless object.is_a? Hash
+            hash = {:body => object.body,
+                    :user_id => object.user_id,
+                    :target_id => object.target_id,
+                    :created_at => object.created_at,
+                    :updated_at => object.updated_at,
+                    :id => object.id,
+                    :project_id => object.prefix_options[:project_id]}
+          else
+            hash = object
+          end
+          super hash
+        end
+      end
+      
+
+      def self.find_by_id(project_id, task_id, id)
+        self.search(project_id, task_id).select { |task| task.id == id }.first
+      end
+
+      def self.find_by_attributes(project_id, task_id, attributes = {})
+        search_by_attribute(self.search(project_id, task_id), attributes)
+      end
+
+      def self.search(project_id, task_id, options = {}, limit = 1000)
+        comments = API.find(:all, :params => {:project_id => project_id, :task_id => task_id, :count => 0}).collect { |comment| self.new comment }
+      end
+
+      def updated_at
+        @updated_at ||= begin
+          Time.parse(self[:updated_at])
+        rescue
+          self[:updated_at]
+        end
+      end
+      
+      def created_at
+        @updated_at ||= begin
+          Time.parse(self[:created_at])
+        rescue
+          self[:created_at]
+        end
+      end
+
+      
+    end
+  end
+end

data/lib/provider/project.rb

@@ -0,0 +1,50 @@
+module TicketMaster::Provider
+  module Teambox
+    # Project class for ticketmaster-teambox
+    #
+    #
+    class Project < TicketMaster::Provider::Base::Project
+      API = TeamboxAPI::Project # The class to access the api's projects
+      # declare needed overloaded methods here
+
+      def tickets(*options)
+        begin
+          if options.first.is_a? Hash
+            #options[0].merge!(:params => {:id => id})
+            super(*options)
+          elsif options.empty?
+            tickets = TeamboxAPI::Task.find(:all, :params => {:project_id => id}).collect { |ticket| TicketMaster::Provider::Teambox::Ticket.new ticket }
+          else
+            super(*options)
+          end
+        rescue
+          []
+        end
+      end
+
+      def ticket!(*options)
+        options[0].merge!(:project_id => id) if options.first.is_a?(Hash)
+        provider_parent(self.class)::Ticket.create(*options)
+      end
+      
+      # copy from this.copy(that) copies that into this
+      def copy(project)
+        project.tickets.each do |ticket|
+          copy_ticket = self.ticket!(:title => ticket.name)
+          ticket.comments.each do |comment|
+            copy_ticket.comment!(:body => comment.body)
+            sleep 1
+          end
+        end
+      end
+
+      def id
+        self[:id]
+      end
+
+
+    end
+  end
+end
+
+

data/lib/provider/teambox.rb

@@ -0,0 +1,38 @@
+module TicketMaster::Provider
+  # This is the Teambox Provider for ticketmaster
+  module Teambox
+    include TicketMaster::Provider::Base
+    TICKET_API = TeamboxAPI::Task # The class to access the api's tickets
+    PROJECT_API = TeamboxAPI::Project # The class to access the api's projects
+    
+    # This is for cases when you want to instantiate using TicketMaster::Provider::Teambox.new(auth)
+    def self.new(auth = {})
+      TicketMaster.new(:teambox, auth)
+    end
+    
+    # Providers must define an authorize method. This is used to initialize and set authentication
+    # parameters to access the API
+    def authorize(auth = {})
+      @authentication ||= TicketMaster::Authenticator.new(auth)
+      auth = @authentication
+      if auth.username.blank? and auth.password.blank? and auth.client_id.nil? and auth.client_secret.nil?
+        raise "Please provide username, password, client id and client secret"
+      end
+      TeamboxAPI.authenticate(auth.client_id, auth.client_secret, auth.username, auth.password)
+    end
+    
+    # declare needed overloaded methods here
+    #
+    def valid?
+      begin
+        PROJECT_API.find(:first)
+        true
+      rescue
+        false
+      end
+    end
+    
+  end
+end
+
+

data/lib/provider/ticket.rb

@@ -0,0 +1,66 @@
+module TicketMaster::Provider
+  module Teambox
+    # Ticket class for ticketmaster-teambox
+    API = TeamboxAPI::Task # The class to access the api's tickets
+    
+    class Ticket < TicketMaster::Provider::Base::Ticket
+      # declare needed overloaded methods here
+      
+      def initialize(*object)
+        if object.first
+          args = object
+          object = args.shift
+          project_id = args.shift
+          @system_data = {:client => object}
+          unless object.is_a? Hash
+           hash = {:status => object.status,
+                   :name => object.name,
+                   :updated_at => object.updated_at,
+                   :id => object.id,
+                   :project_id => project_id.nil? ? object.prefix_options[:project_id] : project_id}
+          else
+            hash = object
+          end
+          super hash
+        end
+      end
+
+      def self.create(*options)
+        task = API.new(options.first.merge!(:status => 1,
+                                            :updated_at => Time.now
+                                            )) 
+        ticket = self.new task
+        task.save
+        ticket
+      end
+
+      def self.find_by_id(project_id, task_id)
+        self.search(project_id, {:id => task_id}).first
+      end
+
+      def self.search(project_id, options = {}, limit = 1000)
+        tickets = API.find(:all, :params => {:project_id => project_id}).collect { |ticket| self.new ticket, project_id }
+        self.search_by_attribute(tickets, options, limit)
+      end
+
+      def self.find_by_attributes(project_id, attributes = {})
+        self.search(project_id, attributes)
+      end
+
+      def project_id
+        self[:project_id]
+      end
+
+      def task_id
+        self[:id]
+      end
+
+      def comment!(*options)
+        options[0].update(:project_id => project_id, :task_id => task_id) if options.first.is_a?(Hash)
+        provider_parent(self.class)::Comment.create(*options)
+      end
+      
+
+    end
+  end
+end

data/lib/teambox/teambox-api.rb

@@ -0,0 +1,274 @@
+require 'rubygems'
+require 'active_support'
+require 'active_resource'
+require 'oauth2'
+
+# Ruby lib for working with the Teambox API's JSON interface.
+# You should set the authentication using your login
+# credentials, client_id and client_secret (OAuth2).
+
+# This library is a small wrapper around the REST interface
+
+module TeamboxAPI
+  class Error < StandardError; end
+  class << self
+    attr_accessor :client_id, :client_secret, :site, :username, :password, :token
+    def authenticate(client_id, client_secret, username, password)
+      @username  = username
+      @password  = password
+      @site = 'https://teambox.com/'
+      @client_id = client_id
+      @client_secret = client_secret
+
+      self::Base.user = username
+      self::Base.password = password
+      self.token = access_token(self)
+
+    end
+
+    def access_token(master)
+      @auth_url = '/oauth/token'
+      consumer = OAuth2::Client.new(master.client_id,
+                                    master.client_secret,
+                                    {:site => 
+                                              {:url => master.site, 
+                                               :ssl => {:verify => OpenSSL::SSL::VERIFY_NONE,
+                                                        :ca_file => nil
+                                                       }
+                                              },
+                                    :authorize_url => @auth_url,
+                                    :parse_json => true})
+                                      
+      response = consumer.request(:post, @auth_url, {:grant_type => 'password', 
+                                                    :client_id => master.client_id,
+                                                    :client_secret => master.client_secret,
+                                                    :username => master.username, 
+                                                    :password => master.password,
+                                                    :scope => 'read_projects write_projects'},
+                                  'Content-Type' => 'application/x-www-form-urlencoded')
+
+      OAuth2::AccessToken.new(consumer, response['access_token']).token
+    
+    end
+
+    def token=(value)
+      resources.each do |klass|
+        klass.headers['Authorization'] = 'OAuth ' + value.to_s
+      end
+      @token = value
+    end
+    
+    def resources
+      @resources ||= []
+    end
+  end
+
+  class Base < ActiveResource::Base
+    self.site = 'https://teambox.com/api/1/'
+    self.format = :json
+    def self.inherited(base)
+      TeamboxAPI.resources << base
+      super
+    end
+  end
+
+  # Find projects
+  #
+  #   TeamboxAPI::Project.find(:all) # find all projects for the current account.
+  #   TeamboxAPI::Project.find(12345)   # find individual project by ID
+  #
+  # Creating a Project
+  #
+  #   project = TeamboxAPI::Project.new(:name => 'Ninja Whammy Jammy')
+  #   project.save
+  #   # => true
+  #
+  #
+  # Updating a Project
+  #
+  #   project = TeamboxAPI::Project.find(12345)
+  #   project.name = "A new name"
+  #   project.save
+  #
+  # Finding tickets
+  # 
+  #   project = TeamboxAPI::Project.find(12345)
+  #   project.tickets
+  #
+
+
+  class Project < Base
+
+    def self.collection_path(organization_path, prefix_options = {}, query_options = nil)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        "#{prefix(prefix_options)}#{organization_path}#{collection_name}.#{format.extension}#{query_string(query_options)}"
+    end
+    
+    def collection_path(options = nil)
+        organization_path = "organizations/#{attributes[:organization_id].to_s}/"
+        self.class.collection_path(organization_path, options || prefix_options)
+    end
+
+    def self.instantiate_collection(collection, prefix_options = {})
+      objects = collection["objects"]
+      objects.collect! { |record| instantiate_record(record, prefix_options) }
+    end
+
+    def tickets(options = {})
+      Task.find(:all, :params => options.update(:project_id => project_id))
+    end
+
+    def project_id
+      self[:id]
+    end
+
+    def encode(options={})
+      val = []
+      attributes.each_pair do |key, value|
+        val << "#{URI.escape key}=#{URI.escape value}" rescue nil
+      end
+      val.join('&')
+    end
+
+    def update
+       connection.put(element_path(prefix_options) + '?' + encode, nil, self.class.headers).tap do |response|
+          load_attributes_from_response(response)
+       end
+    end
+
+    def create
+      connection.post(collection_path + '?' + encode, nil, self.class.headers).tap do |response|
+        self.id = id_from_response(response)
+        load_attributes_from_response(response)
+      end
+    end
+
+    def organization_id
+      attributes[:organization_id]
+    end
+
+    
+    def self.find_every(options)
+          #add :count => 0 in order to retrieve objects with no limits. Default is 20 objects per request.
+          options.merge!(:params => {:count => 0})
+          begin
+            case from = options[:from]
+            when Symbol
+              self.instantiate_collection(get(from, options[:params]))
+            when String
+              path = "#{from}#{query_string(options[:params])}"
+              self.instantiate_collection(connection.get(path, headers) || [])
+            else
+              prefix_options, query_options = split_options(options[:params])
+              path = self.collection_path(nil, prefix_options, query_options)
+              self.instantiate_collection( (connection.get(path, headers) || []), prefix_options )
+            end
+          rescue ActiveResource::ResourceNotFound
+            # Swallowing ResourceNotFound exceptions and return nil - as per
+            # ActiveRecord.
+            nil
+          end
+    end
+
+
+  end
+
+  # Find tickets
+  #
+  #  TeamboxAPI::Task.find(:all, :params => { :name => 'my_project' })
+  #
+  #  project = TeamboxAPI::Project.find('my_project')
+  #  project.tickets
+  #  project.tickets(:name => 'a new name')
+  #
+
+
+  class Task < Base
+
+    self.site += 'projects/:project_id/'
+
+    def self.collection_path(task_list_path, prefix_options = {}, query_options = nil)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        "#{prefix(prefix_options)}#{task_list_path}#{collection_name}.#{format.extension}#{query_string(query_options)}"
+    end
+
+    def collection_path(options = nil)
+        task_list_path = "task_lists/#{attributes[:task_list_id]}/"
+        self.class.collection_path(task_list_path, options || prefix_options)
+    end
+
+    def self.instantiate_collection(collection, prefix_options = {})
+        objects = collection["objects"]
+        objects.collect! { |record| instantiate_record(record, prefix_options) }
+    end
+
+    def encode(options={})
+      val = []
+      attributes.each_pair do |key, value|
+        val << "#{URI.escape key}=#{URI.escape value}" rescue nil
+      end
+      val.join('&')
+    end
+
+    def update
+       connection.put(element_path(prefix_options) + '?' + encode, nil, self.class.headers).tap do |response|
+          load_attributes_from_response(response)
+       end
+    end
+   
+    def create
+      connection.post(collection_path + '?' + encode, nil, self.class.headers).tap do |response|
+        self.id = id_from_response(response)
+        load_attributes_from_response(response)
+      end
+    end
+
+    def self.find_every(options)
+          #add :count => 0 in order to retrieve objects with no limits. Default is 20 objects per request.
+          options[:params].merge!(:count => 0)
+          begin
+            case from = options[:from]
+            when Symbol
+              self.instantiate_collection(get(from, options[:params]))
+            when String
+              path = "#{from}#{query_string(options[:params])}"
+              self.instantiate_collection(connection.get(path, headers) || [])
+            else
+              prefix_options, query_options = split_options(options[:params])
+              path = self.collection_path(nil, prefix_options, query_options)
+              self.instantiate_collection( (connection.get(path, headers) || []), prefix_options )
+            end
+          rescue ActiveResource::ResourceNotFound
+            # Swallowing ResourceNotFound exceptions and return nil - as per
+            # ActiveRecord.
+            nil
+          end
+    end
+
+  end
+
+  class Comment < Base
+    self.site += 'projects/:project_id/tasks/:task_id/'
+
+    def self.instantiate_collection(collection, prefix_options = {})
+        objects = collection["objects"]
+        objects.collect! { |record| instantiate_record(record, prefix_options) }
+    end
+
+    def create
+      connection.post(collection_path + '?' + encode, nil, self.class.headers).tap do |response|
+        load_attributes_from_response(response)
+      end
+    end
+
+    def encode(options={})
+      val=[]
+      attributes.each_pair do |key, value|
+        val << "#{URI.escape key}=#{URI.escape value}" rescue nil
+      end
+      val.join('&')
+    end
+
+  end
+
+end