zensana 1.0.0

data/lib/zensana/models/asana/project.rb

@@ -0,0 +1,84 @@
+module Zensana
+  class Asana
+    class Project
+      include Zensana::Asana::Access
+
+      class << self
+
+        def list
+          @@list ||= Zensana::Asana.inst.fetch '/projects'
+        end
+
+        def search(spec)
+          list.select { |p| p.to_s =~ %r{#{spec}} }
+        rescue RegexpError
+          raise BadSearch, "'#{spec}' is not a valid regular expression"
+        end
+      end
+
+      attr_reader :attributes
+
+      def initialize(spec)
+        @attributes = fetch(spec)
+      end
+
+      def task_list
+        @task_list ||= project_tasks
+      end
+
+      def full_tasks
+        @full_tasks ||= fetch_project_tasks
+      end
+
+      def method_missing(name, *args, &block)
+        attributes[name.to_s] || super
+      end
+
+      private
+
+      def list
+        self.class.list
+      end
+
+      def id
+        self.id
+      end
+
+      def fetch(spec)
+        if is_integer?(spec)
+          fetch_by_id(spec)
+        else
+          fetch_by_name(spec)
+        end
+      end
+
+      def fetch_by_id(id)
+        asana_service.fetch "/projects/#{id}"
+      end
+
+      def fetch_by_name(name)
+        list.each do |project|
+          return fetch_by_id(project['id']) if project['name'] =~ %r{#{name}}
+        end
+        raise NotFound, "No project matches name '#{name}'"
+      rescue RegexpError
+        raise BadSearch, "'#{name}' is not a valid regular expression"
+      end
+
+      def fetch_project_tasks
+        task_list.map { |t| Zensana::Asana::Task.new(t['id']) }
+      end
+
+      def project_tasks
+        asana_service.fetch "/projects/#{id}/tasks"
+      rescue NotFound
+        []
+      end
+
+      def is_integer?(id)
+        Integer(id) rescue false
+      end
+
+    end
+  end
+end

data/lib/zensana/models/asana/task.rb

@@ -0,0 +1,86 @@
+module Zensana
+  class Asana
+    class Task
+      include Zensana::Asana::Access
+
+      FIELDS = [
+        'id', 'name', 'notes', 'created_at', 'created_by.name',
+        'completed', 'assignee.name', 'tags.name', 'followers.name'
+      ]
+
+      attr_reader :attributes
+
+      def initialize(id)
+        @attributes = fetch(id)
+      end
+
+      def tags
+        attributes['tags'].map { |t| snake_case t['name'] } if attributes['tags']
+      end
+
+      def is_section?
+        self.name.end_with?(':') rescue false
+      end
+
+      def section_name
+        self.name.chop if is_section?
+      end
+
+      def subtasks
+        @subtasks ||= fetch_subtasks(self.id)
+      end
+
+      def stories
+        @stories ||= story_list(self.id)
+      end
+
+      def attachments
+        @attachments ||= fetch_attachments(self.id)
+      end
+
+      def method_missing(name, *args, &block)
+        attributes[name.to_s] || super
+      end
+
+      private
+
+      def fetch(id)
+        asana_service.fetch("/tasks/#{id}?opt_fields=#{opt_fields}")
+      end
+
+      def fetch_subtasks(id)
+        subtask_list(id).map { |s| Zensana::Asana::Task.new(s['id']) }
+      end
+
+      def subtask_list(id)
+        asana_service.fetch "/tasks/#{id}/subtasks"
+      rescue NotFound
+        nil
+      end
+
+      def fetch_attachments(id)
+        attachment_list(id).map { |s| Zensana::Asana::Attachment.new(s['id']) }
+      end
+
+      def attachment_list(id)
+        asana_service.fetch "/tasks/#{id}/attachments"
+      rescue NotFound
+        nil
+      end
+
+      def story_list(id)
+        asana_service.fetch "/tasks/#{id}/stories"
+      rescue NotFound
+        nil
+      end
+
+      def opt_fields
+        FIELDS.map { |f| f.to_s }.join(',')
+      end
+
+      def snake_case(string)
+        string.gsub(/(.)([A-Z])/,'\1_\2').downcase
+      end
+    end
+  end
+end

data/lib/zensana/models/asana/user.rb

@@ -0,0 +1,35 @@
+module Zensana
+  class Asana
+    class User
+      include Zensana::Asana::Access
+
+      def self.list
+        @@list ||= Zensana::Asana.inst.fetch '/users'
+      end
+
+      attr_reader :attributes
+
+      def initialize(id)
+        @attributes = fetch(id)
+      end
+
+      def method_missing(name, *args, &block)
+        attributes[name.to_s] || super
+      end
+
+      private
+
+      def fetch(id)
+        if cache[id] then
+          cache[id]
+        else
+          cache[id] = asana_service.fetch("/users/#{id}")
+        end
+      end
+
+      def cache
+        @@cache ||= {}
+      end
+    end
+  end
+end

data/lib/zensana/models/zendesk/attachment.rb

@@ -0,0 +1,38 @@
+module Zensana
+  class Zendesk
+    class Attachment
+      include Zensana::Zendesk::Access
+
+      attr_reader :attributes
+
+      def initialize
+        @attributes = {}
+      end
+
+      def upload(filename)
+        @attributes = upload_file(filename)
+      end
+
+      def method_missing(name, *args, &block)
+        attributes[name.to_s] || super
+      end
+
+      private
+
+      def upload_file(file)
+        raise NotFound, "#{file} does not exist" unless File.exist?(file)
+        zendesk_service.create(
+          "/uploads.json",
+          :headers => {
+            "Content-Type" => "application/binary"
+          },
+          :detect_mime_type => true,
+          :body => {
+            "filename"      => "#{File.basename(file)}",
+            "uploaded_data" => File.new(file)
+          },
+          )['upload']
+      end
+    end
+  end
+end

data/lib/zensana/models/zendesk/comment.rb

@@ -0,0 +1,34 @@
+module Zensana
+  class Zendesk
+    class Comment
+      include Zensana::Validate::Key
+
+      REQUIRED_KEYS = [ :author_id, :value ]
+      OPTIONAL_KEYS = [ :created_at, :public, :uploads ]
+
+      # Class validates the comment attributes
+      # added during the Ticket Import call.
+      # Comments cannot be created this way
+      # for existing tickets.
+
+      attr_reader :attributes
+
+      def initialize(attributes)
+        validate_keys attributes
+        #id = attributes['author_id']
+        #raise NotFound, "Author #{id} does not exist" unless author_exists?(id)
+        @attributes = attributes
+      end
+
+      def author_exists?(id)
+        !! Zendesk::User.new.find(id)
+      rescue NotFound
+        false
+      end
+
+      def method_missing(name, *args, &block)
+        attributes[name.to_s] || super
+      end
+    end
+  end
+end

data/lib/zensana/models/zendesk/ticket.rb

@@ -0,0 +1,73 @@
+require 'json'
+
+module Zensana
+  class Zendesk
+    class Ticket
+      include Zensana::Zendesk::Access
+      include Zensana::Validate::Key
+
+      # if external_id is present for a ticket in
+      # ZenDesk then we can say that it was already created
+      def self.external_id_exists?(external_id)
+        query = "/search.json?query=type:ticket,,external_id:#{external_id}"
+        external_id && (result = Zensana::Zendesk.inst.fetch(query)['results']) &&
+          ! (result.nil? || result.empty?)
+      end
+
+      REQUIRED_KEYS = [:requester_id ]
+      OPTIONAL_KEYS = [
+        :external_id, :type, :subject, :description, :priority, :status,
+        :submitter_id, :assignee_id, :group_id, :collaborator_ids, :tags,
+        :created_at, :updated_id, :comments, :solved_at, :updated_at
+      ]
+
+      attr_reader :attributes
+
+      def initialize(attributes)
+        @attributes = attributes || {}
+      end
+
+      def find(id)
+        @attributes = fetch(id)
+      end
+
+      def import(attributes=@attributes)
+        validate_keys attributes
+        raise AlreadyExists, "This ticket has already been imported with id #{self.id}" if imported?
+        import_ticket(attributes)
+      end
+
+      def imported?
+        !! id
+      end
+
+      def id
+        attributes['id']
+      end
+
+      def external_id
+        attributes['external_id']
+      end
+
+      def method_missing(name, *args, &block)
+        attributes[name.to_s] || super
+      end
+
+      private
+
+      def import_ticket(attributes)
+        unless attributes['ticket']
+          attributes = { 'ticket' => attributes }
+        end
+        zendesk_service.create(
+          "/imports/tickets.json",
+          :body => JSON.generate(attributes)
+        )['ticket']
+      end
+
+      def fetch(id)
+        zendesk_service.fetch("/tickets/#{id}.json")['ticket']
+      end
+    end
+  end
+end

data/lib/zensana/models/zendesk/user.rb

@@ -0,0 +1,96 @@
+require 'json'
+
+module Zensana
+  class Zendesk
+    class User
+      include Zensana::Zendesk::Access
+      include Zensana::Validate::Key
+
+      REQUIRED_KEYS = [ :name, :email ]
+      OPTIONAL_KEYS = [ :time_zone, :locale_id, :organization_id, :role, :verified, :phone, :photo ]
+
+      attr_reader :attributes
+
+      def initialize
+        @attributes = {}
+      end
+
+      def find(spec)
+        @attributes = lookup(spec)
+      end
+
+      def create(attributes)
+        validate_keys attributes
+        email = attributes['email'] || attributes['user']['email']
+        raise AlreadyExists, "User '#{email}' already exists" if lookup_by_email(email)
+      rescue NotFound
+        user = create_user(attributes)
+        update_cache user
+        @attributes = user
+      end
+
+      def method_missing(name, *args, &block)
+        attributes[name.to_s] || super
+      end
+
+      private
+
+      def lookup(spec)
+        if spec.is_a?(Fixnum)
+          lookup_by_id spec
+        else
+          lookup_by_email spec
+        end
+      end
+
+      def lookup_by_id(id)
+        unless (user = read_cache(id))
+          user = fetch(id)
+          update_cache user
+        end
+        user
+      end
+
+      def lookup_by_email(email)
+        unless (user = read_cache(email))
+          user = search("email:#{email}")
+          update_cache user
+        end
+        user
+      end
+
+      def create_user(attributes)
+        unless attributes['user'].is_a?(Hash)
+          attributes = { 'user' => attributes }
+        end
+        zendesk_service.create(
+          "/users.json",
+          :body => JSON.generate(attributes)
+        )['user']
+      end
+
+      def cache
+        @@cache ||= {}
+      end
+
+      def read_cache(key)
+        cache[key.to_s]
+      end
+
+      def update_cache(user)
+        [ :id, :email ].each do |attr|
+          key = user[attr].to_s
+          cache[key] = user
+        end
+      end
+
+      def fetch(id)
+        zendesk_service.fetch("/users/#{id}.json")['user']
+      end
+
+      def search(query)
+        zendesk_service.fetch("/users/search.json?query=#{query}")['users'].first
+      end
+    end
+  end
+end

data/lib/zensana/services/asana.rb

@@ -0,0 +1,48 @@
+require 'httmultiparty'
+
+module Zensana
+  class Asana
+    include HTTMultiParty
+    base_uri 'https://app.asana.com/api/1.0'
+    headers 'Content-Type' => 'application/json; charset=utf-8'
+    default_timeout 10
+    #debug_output
+
+    def self.inst
+      @inst ||= new
+    end
+
+    module Access
+      def asana_service
+        @asana_service ||= Zensana::Asana.inst
+      end
+    end
+
+    def initialize
+      user, pword = if ENV['ASANA_USERNAME']
+                      [ ENV['ASANA_USERNAME'], ENV['ASANA_PASSWORD'] ]
+                    else
+                      [ ENV['ASANA_API_KEY'], nil ]
+                    end
+      self.class.basic_auth user, pword
+    end
+
+    def fetch(path, params={}, &block)
+      request :get, path, params, &block
+    end
+
+    def request(method, path, params={}, &block)
+      result = self.class.send(method, path, params)
+
+      Zensana::Error.handle_http_errors result
+
+      Zensana::Response.new(result).tap do |response|
+        block.call(response) if block_given?
+      end
+
+    rescue Net::OpenTimeout
+      raise Unprocessable, "Connection timed out"
+    end
+
+  end
+end

data/lib/zensana/services/error.rb

@@ -0,0 +1,55 @@
+require 'json'
+
+module Zensana
+  class Error < StandardError
+    def self.msg=(msg)
+      @msg = msg
+    end
+
+    def self.msg
+      @msg
+    end
+
+    def initialize(msg=nil)
+      super msg || self.class.msg
+    end
+
+    def self.handle_http_errors(http_response)
+      body = JSON.parse(http_response.body)
+      message = if body['errors']
+                  body['errors'].first['message']
+                else
+                  body
+                end
+    rescue
+      nil
+    ensure
+      case http_response.code
+      when 200, 201 then return
+      when 404 then raise NotFound, message
+      when 401..403 then raise AccessDenied, message
+      else raise Unprocessable, message
+      end
+    end
+  end
+
+  class AccessDenied < Error
+    self.msg = 'Access denied - check credentials'
+  end
+
+  class AlreadyExists < Error
+    self.msg = 'That item already exists'
+  end
+
+  class BadSearch < Error
+    self.msg = 'That is an invalid regular expression'
+  end
+
+  class NotFound < Error
+    self.msg = 'That item does not exist'
+  end
+
+  class Unprocessable < Error
+    self.msg = 'Something went wrong in the external service'
+  end
+end

data/lib/zensana/services/response.rb

@@ -0,0 +1,49 @@
+require 'awesome_print'
+
+module Zensana
+  class Response
+    include Enumerable
+
+    def each(&block)
+      @data.each(&block)
+    end
+
+    def initialize(http_response)
+      @ok   = http_response.success?
+      body  = JSON.parse(http_response.body) rescue {}
+      @data = body['data'] || body
+    end
+
+    def ok?
+      @ok
+    end
+
+    def has_more_pages?
+      !! next_page
+    end
+
+    def next_page
+      @data['next_page']
+    end
+
+    def [](key)
+      @data.is_a?(Hash) ? @data[key.to_s] : key.is_a?(Integer) ? @data[key] : nil
+    end
+
+    def to_h
+      @data.respond_to?('to_h') ? @data.to_h : @data
+    end
+
+    def to_a
+      @data.respond_to?('to_a') ? @data.to_a : @data
+    end
+
+    def to_s
+      @data.respond_to?('to_s') ? @data.to_s : @data
+    end
+
+    def pretty
+      ap @data
+    end
+  end
+end

data/lib/zensana/services/zendesk.rb

@@ -0,0 +1,54 @@
+require 'httmultiparty'
+
+module Zensana
+  class Zendesk
+    include HTTMultiParty
+    default_timeout 10
+    #debug_output
+
+    def self.inst
+      @inst ||= new
+    end
+
+    module Access
+      def zendesk_service
+        @zendesk_service ||= Zensana::Zendesk.inst
+      end
+    end
+
+    def initialize
+      self.class.base_uri "https://#{ENV['ZENDESK_DOMAIN']}.zendesk.com/api/v2"
+      self.class.basic_auth ENV['ZENDESK_USERNAME'], ENV['ZENDESK_PASSWORD']
+    end
+
+    def fetch(path, params={}, &block)
+      request :get, path, params, &block
+    end
+
+    def create(path, params={}, &block)
+      request :post, path, params, &block
+    end
+
+    def request(method, path, params={}, &block)
+      unless params[:headers]
+        params[:headers] = {
+          "Content-Type" => "application/json"
+        }
+      end
+      path = relative_path(path)
+      result = self.class.send(method, path, params)
+
+      Zensana::Error.handle_http_errors result
+
+      Zensana::Response.new(result).tap do |response|
+        block.call(response) if block_given?
+      end
+    end
+
+    private
+
+    def relative_path(path)
+      path.sub(self.class.base_uri, '')
+    end
+  end
+end

data/lib/zensana/validate/key.rb

@@ -0,0 +1,44 @@
+module Zensana
+  class MissingKey    < Zensana::Error; end
+  class UnknownKey    < Zensana::Error; end
+  class UndefinedKeys < Zensana::Error; end
+
+  module Validate
+    module Key
+      def validate_keys(hash)
+        raise MissingKey, "Mandatory keys are: #{required_keys}" unless has_required_keys?(hash)
+        raise UnknownKey, "Valid keys are: #{valid_keys}" if has_unknown_keys?(hash)
+      end
+
+      def has_required_keys?(hash)
+        required_keys.all? { |k| hash.key? k }
+      end
+
+      def has_unknown_keys?(hash)
+        ! (hash.keys - valid_keys).empty?
+      end
+
+      def valid_keys
+        @valid_keys ||= required_keys + optional_keys
+      end
+
+      def required_keys
+        @required_keys ||= begin
+                             const = "#{self.class}::REQUIRED_KEYS"
+                             Object.const_get const
+                           rescue NameError
+                             raise UndefinedKeys, "You must define #{const}"
+                           end
+      end
+
+      def optional_keys
+        @optional_keys ||= begin
+                             const = "#{self.class}::OPTIONAL_KEYS"
+                             Object.const_get const
+                           rescue NameError
+                             raise UndefinedKeys, "You must define #{const}"
+                           end
+      end
+    end
+  end
+end

data/lib/zensana/version.rb

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