motion-tickspot 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c1750234a64316c38c16789b8eb82c7eda4f1c3
+  data.tar.gz: c66fb44d97c5b63883542ff6de3128684c748fa4
+SHA512:
+  metadata.gz: ff3586ed69f69201d794b7caafc66fbef0b4fa0e6a9df04f29096e05002f514cf0278d0c931e792d25edfa095dbaf6a59e2ca86e44165f8834d1a1bd74bb358e
+  data.tar.gz: bece59d96ac4aae2410c8a8124184422c3eecb10350597cfbbd756b383ee352d4e5fe12955b147bfa24d2cce109e81f8bb00a76ee6cd20526c9bb52d767bb54c

data/README.md

@@ -0,0 +1,114 @@
+# Motion-Tickspot
+
+[![Build Status](https://travis-ci.org/81designs/motion-tickspot.png?branch=master)](https://travis-ci.org/81designs/motion-tickspot)
+[![Code Climate](https://codeclimate.com/github/81designs/motion-tickspot.png)](https://codeclimate.com/github/81designs/motion-tickspot)
+
+A [RubyMotion](http://www.rubymotion.com) wrapper for the
+[Tick](http://www.tickspot.com)'s [API](http://www.tickspot.com/api)
+that works on iOS and OS X.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "motion-tickspot"
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install motion-tickspot
+```
+
+## Usage
+
+### Authentication
+
+Authentication is handled by `Tick::Session` with some convenience methods.
+
+[SSKeychain](https://github.com/soffes/sskeychain) is being used to 
+save the user's password to the iOS or OS X keychain.
+
+```ruby
+Tick.logged_in? # true/false
+
+Tick.log_in("company/subdomain", "email@example.com", "password") do |session|
+  if session
+    # Success!
+  else
+    # Failed to log in
+  end
+end
+
+Tick.log_out
+```
+
+### Tick::Client
+
+```ruby
+Tick::Client.list do |clients|
+  # Returns array of Tick::Clients
+  # Raises Tick::AuthenticationError if not logged in
+end
+```
+
+### Tick::Entry
+
+```ruby
+Tick::Entry.create({
+  task_id: 1,
+  hours: 2.5,
+  date: "2008-03-17",
+  notes: "She can't take much more of this Captain"
+}) do |entry|
+  # Returns the saved Tick::Entry
+  # Raises Tick::AuthenticationError if not logged in
+end
+```
+
+```ruby
+Tick::Entry.list do |entries|
+  # Returns array of Tick::Entries
+  # Raises Tick::AuthenticationError if not logged in
+end
+```
+
+### Tick::Project
+
+```ruby
+Tick::Project.list do |projects|
+  # Returns array of Tick::Projects
+  # Raises Tick::AuthenticationError if not logged in
+end
+```
+
+### Tick::Session
+
+```ruby
+Tick::Session.current
+# Returns Tick::Session instance or nil
+```
+
+### Tick::Task
+
+```ruby
+Tick::Task.list do |tasks|
+  # Returns array of Tick::Tasks
+  # Raises Tick::AuthenticationError if not logged in
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/motion-tickspot.rb

@@ -0,0 +1,16 @@
+require "motion-cocoapods"
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "tick/**/*.rb")))
+  
+  app.pods do
+    pod "AFNetworking", "~> 2.0.1"
+    pod "GDataXML-HTML", "~> 1.1.0"
+    pod "SSKeychain", "~> 1.2.1"
+  end
+end

data/lib/tick/base.rb

@@ -0,0 +1,152 @@
+module Tick
+  
+  DATE_FORMAT = "yyyy-MM-dd"
+  DATETIME_FORMAT = "EE, dd MMM yyyy HH:mm:ss ZZZ"
+  
+  class << self
+    
+    def log_in(company, email, password, &block)
+      params = {
+        company: company,
+        email: email,
+        password: password
+      }
+      Session.create(params) do |session|
+        block.call(session) if block
+      end
+    end
+    alias_method :login, :log_in
+  
+    def log_out
+      Session.current.destroy if Session.current
+    end
+    alias_method :logout, :log_out
+  
+    def logged_in?
+      Session.logged_in?
+    end
+    
+  end
+  
+  class Base
+    attr_accessor :id, :created_at, :updated_at
+    attr_reader :api_name, :api_path
+    
+    def set_properties_from_xml_node(xml_node)
+      self.class::XML_PROPERTIES.each do |property|
+        xml_elements = xml_node.elementsForName(property)
+        value = xml_elements ? get_xml_element_value(xml_elements.first) : nil
+        self.send("#{property}=", value)
+      end
+    end
+    
+    def self.api_name
+      self.to_s.split('::').last.downcase
+    end
+    
+    def self.api_path
+      "/api/#{api_name}s"
+    end
+    
+    def self.list(options={}, &block)
+      url = "https://#{current_session.company}.tickspot.com#{api_path}"
+      
+      params = authentication_params.merge!(options)
+      
+      request_manager.GET(url, parameters:params, success:lambda{|operation, result|
+        objects = []
+        
+        # Parse XML
+        error = Pointer.new(:object)
+        xml = GDataXMLDocument.alloc.initWithXMLString(result.to_s, error:error)
+        
+        # Create the objects
+        error = Pointer.new(:object)
+        xml_nodes = xml.nodesForXPath("//#{api_name}", error:error)
+        
+        xml_nodes.each do |xml_node|
+          object = new
+          object.set_properties_from_xml_node(xml_node)
+          objects << object
+        end
+        
+        block.call(objects) if block
+      }, failure:lambda{|operation, error|
+        block.call(error) if block
+      })
+      
+      self
+    end
+    
+  private
+  
+    def get_xml_element_value(xml_element)
+      type = xml_element.attributeForName("type")
+      type = type.stringValue if type
+      case type
+      when "boolean"
+        xml_element.stringValue.boolValue
+      when "date"
+        date_from_string(xml_element.stringValue)
+      when "datetime"
+        datetime_from_string(xml_element.stringValue)
+      when "float"
+        xml_element.stringValue.floatValue
+      when "integer"
+        xml_element.stringValue.intValue
+      else
+        value = xml_element.stringValue
+        if value == "true"
+          true
+        elsif value == "false"
+          false
+        else
+          value
+        end
+      end
+    end
+    
+    def date_from_string(string)
+      dateFormatter = NSDateFormatter.new
+      dateFormatter.setDateFormat(DATE_FORMAT)
+      dateFormatter.dateFromString(string)
+    end
+    
+    def datetime_from_string(string)
+      dateFormatter = NSDateFormatter.new
+      dateFormatter.setDateFormat(DATETIME_FORMAT)
+      dateFormatter.dateFromString(string)
+    end
+    
+    def self.authentication_params
+      {
+        email: current_session.email,
+        password: current_session.password
+      }
+    end
+    
+    def self.current_session
+      if Session.current
+        Session.current
+      else
+        raise AuthenticationError.new("User is not logged in.")
+      end
+    end
+  
+    def self.request_manager
+      manager = AFHTTPRequestOperationManager.manager
+      
+      request_serializer = AFHTTPRequestSerializer.serializer
+      request_serializer.setValue("application/xml", forHTTPHeaderField:"Content-type")
+      manager.requestSerializer = request_serializer
+      
+      response_serializer = AFHTTPResponseSerializer.serializer
+      response_serializer.acceptableContentTypes = NSSet.setWithObjects("application/xml", nil)
+      manager.responseSerializer = response_serializer
+      
+      manager
+    end
+    
+  end
+  
+end

data/lib/tick/client.rb

@@ -0,0 +1,8 @@
+module Tick
+  
+  class Client < Tick::Base
+    attr_accessor :name
+    XML_PROPERTIES = %w( id name )
+  end
+  
+end

data/lib/tick/entry.rb

@@ -0,0 +1,48 @@
+module Tick
+  
+  class Entry < Tick::Base
+    attr_accessor :billable, :billed, :budget, :client_name,
+                  :date, :hours, :notes, :project_name, :sum_hours, 
+                  :task_id, :task_name, :user_email, :user_id
+                  
+    XML_PROPERTIES = %w( id billable billed budget client_name created_at date hours notes
+                         project_name sum_hours task_id task_name updated_at user_email user_id )
+                         
+    def self.api_path
+      "/api/entries"
+    end
+                         
+    def self.create(options={}, &block)
+      url  = "https://#{current_session.company}.tickspot.com/api/create_entry"
+      
+      params = {
+        email: current_session.email,
+        password: current_session.password
+      }.merge!(options)
+      
+      if params[:date].is_a?(NSDate)
+        dateFormatter = NSDateFormatter.new
+        dateFormatter.setDateFormat(DATE_FORMAT)
+        params[:date] = dateFormatter.stringFromDate(params[:date])
+      end
+      
+      request_manager.GET(url, parameters:params, success:lambda{|operation, result|
+        error = Pointer.new(:object)
+        xml = GDataXMLDocument.alloc.initWithXMLString(result.to_s, error:error)
+        
+        # Create the entry object from xml
+        error = Pointer.new(:object)
+        entry_node = xml.nodesForXPath("//entry", error:error).first
+        entry = new
+        entry.set_properties_from_xml_node(entry_node)
+        block.call(entry) if block
+      }, failure:lambda{|operation, error|
+        block.call(error) if block
+      })
+      
+      self
+    end
+    
+  end
+  
+end

data/lib/tick/project.rb

@@ -0,0 +1,70 @@
+module Tick
+  
+  class Project < Tick::Base
+    attr_accessor :budget, :client_id, :client_name, :closed_on,
+                  :name, :opened_on, :owner_id, :sum_hours, :tasks,
+                  :user_count
+                  
+    XML_PROPERTIES = %w( id budget client_id client_name closed_on created_at 
+                         name opened_on owner_id sum_hours updated_at user_count )
+    
+    def self.list(options={}, &block)
+      url = "https://#{current_session.company}.tickspot.com/api/projects"
+      
+      params = authentication_params.merge!(options)
+      
+      request_manager.GET(url, parameters:params, success:lambda{|operation, result|
+        projects = []
+        
+        # Parse XML
+        error = Pointer.new(:object)
+        xml = GDataXMLDocument.alloc.initWithXMLString(result.to_s, error:error)
+        
+        # Create the project objects
+        error = Pointer.new(:object)
+        project_nodes = xml.nodesForXPath("//project", error:error)
+        
+        project_nodes.each do |project_node|
+          project = new
+          project.set_properties_from_xml_node(project_node)
+          project.tasks = get_tasks_from_xml_node(project_node)
+          project.tasks.each do |task|
+            task.project = project
+          end
+          projects << project
+        end
+        
+        block.call(projects) if block
+      }, failure:lambda{|operation, error|
+        block.call(error) if block
+      })
+      
+      self
+    end
+    
+  private
+    
+    def self.get_tasks_from_xml_node(xml_node)
+      tasks = []
+      
+      # Seems to be mixed results when parsing the XML where
+      # sometimes the tasks element doesn't exist
+      tasks_elements = xml_node.elementsForName("tasks")
+      if tasks_elements
+        task_nodes = tasks_elements.first.elementsForName("task")
+      else
+        task_nodes = xml_node.elementsForName("task")
+      end
+      
+      task_nodes.each do |task_node|
+        task = Task.new
+        task.set_properties_from_xml_node(task_node)
+        tasks << task
+      end
+      
+      tasks
+    end
+    
+  end
+  
+end

data/lib/tick/session.rb

@@ -0,0 +1,111 @@
+module Tick
+  
+  class AuthenticationError < Exception
+  end
+  
+  class Session < Tick::Base
+    attr_accessor :company, :email, :first_name, :last_name, :password
+  
+    SERVICE_NAME = "Tick Timer"
+  
+    def company
+      @company ||= storage.objectForKey("company")
+    end
+  
+    def company=(value)
+      @company = value
+      storage.setObject(value, forKey:"company")
+      storage.synchronize
+      @company
+    end
+    
+    def destroy
+      storage.removeObjectForKey("company")
+      storage.removeObjectForKey("email")
+      SSKeychain.deletePasswordForService(SERVICE_NAME, account:email)
+      self.class.current = nil
+    end
+  
+    def email
+      @email ||= storage.objectForKey("email")
+    end
+  
+    def email=(value)
+      @email = value
+      storage.setObject(value, forKey:"email")
+      storage.synchronize
+      @email
+    end
+    
+    def first_name
+      @first_name ||= storage.objectForKey("first_name")
+    end
+  
+    def first_name=(value)
+      @first_name = value
+      storage.setObject(value, forKey:"first_name")
+      storage.synchronize
+      @first_name
+    end
+    
+    def last_name
+      @last_name ||= storage.objectForKey("last_name")
+    end
+  
+    def last_name=(value)
+      @last_name = value
+      storage.setObject(value, forKey:"last_name")
+      storage.synchronize
+      @last_name
+    end
+  
+    def password
+      @password ||= SSKeychain.passwordForService(SERVICE_NAME, account:email)
+    end
+  
+    def password=(value)
+      @password = value
+      SSKeychain.setPassword(value, forService:SERVICE_NAME, account:email)
+      @password
+    end
+  
+    def storage
+      NSUserDefaults.standardUserDefaults
+    end
+    
+    def self.create(params, &block)
+      url  = "https://#{params[:company]}.tickspot.com/api/users"
+      
+      company = params[:company]
+      params.delete(:company)
+  
+      request_manager.GET(url, parameters:params, success:lambda{|operation, result|
+        # TODO: Save first and last name
+        @current = new
+        @current.company = company
+        @current.email = params[:email]
+        @current.password = params[:password]
+        block.call(@current) if block
+      }, failure:lambda{|operation, error|
+        ap error
+        block.call(nil) if block
+      })
+      
+      self
+    end
+  
+    def self.current
+      @current || (logged_in? ? new : nil)
+    end
+    
+    def self.current=(value)
+      @current = value
+    end
+    
+    def self.logged_in?
+      (@current && @current.company && @current.email && @current.password) ? true : false
+    end
+  
+  end
+  
+end

data/lib/tick/task.rb

@@ -0,0 +1,11 @@
+module Tick
+  
+  class Task < Tick::Base
+    attr_accessor :billable, :budget, :closed_on, :name, :opened_on, 
+                  :position, :project, :project_id, :sum_hours, :user_count
+                  
+    XML_PROPERTIES = %w( id billable budget closed_on name 
+                         opened_on position project_id sum_hours user_count )
+  end
+  
+end

data/lib/tick/timer.rb

@@ -0,0 +1,135 @@
+module Tick
+  
+  class Timer
+    attr_accessor :start_time, :task, :time_spans
+    
+    def clear
+      self.start_time = nil
+      self.time_spans = []
+      self.class.list.delete(self)
+      true
+    end
+    
+    def displayed_time
+      hours = self.time_elapsed_in_hours.to_i
+      minutes = (self.time_elapsed_in_seconds / 60).to_i - (hours * 60)
+    
+      hours = hours.to_s
+      hours = "0#{hours}" if hours.length == 1
+    
+      minutes = minutes.to_s
+      minutes = "0#{minutes}" if minutes.length == 1
+    
+      "#{hours}:#{minutes}"
+    end
+    
+    def initialize
+      self.start
+      self
+    end
+    
+    def is_paused
+      self.start_time.nil?
+    end
+    alias_method :paused, :is_paused
+    alias_method :is_stopped, :is_paused
+    alias_method :stopped, :is_paused
+    
+    def is_running
+      !self.start_time.nil?
+    end
+    alias_method :running, :is_running
+    alias_method :is_started, :is_running
+    alias_method :started, :is_running
+    
+    def start
+      # Stop the current timer if it exists
+      current_timer = self.class.current
+      current_timer.stop if current_timer
+      
+      # Start the timer and add it to the
+      # list of timers if it doesn't exist
+      self.start_time = Time.now
+      unless self.class.list.include?(self)
+        self.class.list << self
+      end
+      
+      true
+    end
+    alias_method :resume, :start
+    
+    def stop
+      self.time_spans << Time.now - self.start_time
+      self.start_time = nil
+      true
+    end
+    alias_method :pause, :stop
+    
+    def submit!(options={}, &block)
+      dateFormatter = NSDateFormatter.new
+      dateFormatter.setDateFormat(DATE_FORMAT)
+      
+      params = {
+        task_id: self.task.id,
+        hours: self.time_elapsed_in_hours,
+        date: Time.now
+      }.merge!(options)
+      
+      entry = Entry.create(params) do |result|
+        self.clear
+        block.call(result) if block
+      end
+      
+      self
+    end
+    
+    def time_elapsed_in_seconds
+      time_elapsed_in_seconds = 0
+      
+      # Add up time spans
+      self.time_spans.each do |seconds|
+        time_elapsed_in_seconds += seconds
+      end
+      
+      # Add the current running time
+      if self.start_time
+        time_elapsed_in_seconds += Time.now - self.start_time
+      end
+      
+      time_elapsed_in_seconds
+    end
+  
+    def time_elapsed_in_hours
+      self.time_elapsed_in_seconds / 60 / 60
+    end
+    
+    def time_spans
+      @time_spans ||= []
+    end
+    
+    def self.current
+      list.select{|timer|
+        timer.is_running
+      }.first
+    end
+    
+    def self.list
+      @@list ||= []
+    end
+    
+    def self.start_with_task(task)
+      timer = list.select{|timer|
+        timer.task.id == task.id
+      }.first
+      
+      if timer.nil?
+        timer = new
+        timer.task = task
+      end
+      
+      timer
+    end
+    
+  end
+  
+end

data/lib/tick/version.rb

@@ -0,0 +1,3 @@
+module Tick
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: motion-tickspot
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Pattison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: awesome_print_motion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: guard-motion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: motion-redgreen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: RackMotion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.3
+description: Motion Tickspot is a RubyMotion wrapper for accessing the Tick time tracking
+  service using the http://tickspot.com API.
+email:
+- brian@brianpattison.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/motion-tickspot.rb
+- lib/tick/base.rb
+- lib/tick/client.rb
+- lib/tick/entry.rb
+- lib/tick/project.rb
+- lib/tick/session.rb
+- lib/tick/task.rb
+- lib/tick/timer.rb
+- lib/tick/version.rb
+homepage: https://github.com/81designs/motion-tickspot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A RubyMotion wrapper for the http://tickspot.com API
+test_files: []
+has_rdoc: