amorail 0.5.0

data/lib/amorail/client.rb

@@ -0,0 +1,101 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'json'
+require 'active_support'
+
+module Amorail
+  # Amorail http client
+  class Client
+    SUCCESS_STATUS_CODES = [200, 204].freeze
+
+    attr_reader :usermail, :api_key, :api_endpoint
+
+    def initialize(api_endpoint: Amorail.config.api_endpoint,
+                   api_key: Amorail.config.api_key,
+                   usermail: Amorail.config.usermail)
+      @api_endpoint = api_endpoint
+      @api_key = api_key
+      @usermail = usermail
+      @connect = Faraday.new(url: api_endpoint) do |faraday|
+        faraday.response :json, content_type: /\bjson$/
+        faraday.use :instrumentation
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def properties
+      @properties ||= Property.new(self)
+    end
+
+    def connect
+      @connect || self.class.new
+    end
+
+    def authorize
+      self.cookies = nil
+      response = post(
+        Amorail.config.auth_url,
+        'USER_LOGIN' => usermail,
+        'USER_HASH' => api_key
+      )
+      cookie_handler(response)
+      response
+    end
+
+    def safe_request(method, url, params = {})
+      public_send(method, url, params)
+    rescue ::Amorail::AmoUnauthorizedError
+      authorize
+      public_send(method, url, params)
+    end
+
+    def get(url, params = {})
+      response = connect.get(url, params) do |request|
+        request.headers['Cookie'] = cookies if cookies.present?
+      end
+      handle_response(response)
+    end
+
+    def post(url, params = {})
+      response = connect.post(url) do |request|
+        request.headers['Cookie'] = cookies if cookies.present?
+        request.headers['Content-Type'] = 'application/json'
+        request.body = params.to_json
+      end
+      handle_response(response)
+    end
+
+    private
+
+    attr_accessor :cookies
+
+    def cookie_handler(response)
+      self.cookies = response.headers['set-cookie'].split('; ')[0]
+    end
+
+    def handle_response(response) # rubocop:disable all
+      return response if SUCCESS_STATUS_CODES.include?(response.status)
+
+      case response.status
+      when 301
+        fail ::Amorail::AmoMovedPermanentlyError
+      when 400
+        fail ::Amorail::AmoBadRequestError
+      when 401
+        fail ::Amorail::AmoUnauthorizedError
+      when 403
+        fail ::Amorail::AmoForbiddenError
+      when 404
+        fail ::Amorail::AmoNotFoundError
+      when 500
+        fail ::Amorail::AmoInternalError
+      when 502
+        fail ::Amorail::AmoBadGatewayError
+      when 503
+        fail ::Amorail::AmoServiceUnaviableError
+      else
+        fail ::Amorail::AmoUnknownError, response.body
+      end
+    end
+  end
+end

data/lib/amorail/config.rb

@@ -0,0 +1,17 @@
+require 'anyway'
+
+module Amorail
+  # Amorail config contains:
+  # - usermail ("user@gmail.com")
+  # - api_key ("13601bbac84727df")
+  # - api_endpoint ("http://you_company.amocrm.com")
+  # - api_path (default: "/private/api/v2/json/")
+  # - auth_url (default: "/private/api/auth.php?type=json")
+  class Config < Anyway::Config
+    attr_config :usermail,
+                :api_key,
+                :api_endpoint,
+                api_path: "/private/api/v2/json/",
+                auth_url: "/private/api/auth.php?type=json"
+  end
+end

data/lib/amorail/entities/company.rb

@@ -0,0 +1,23 @@
+require 'amorail/entities/leadable'
+
+module Amorail
+  # AmoCRM company entity
+  class Company < Amorail::Entity
+    include Leadable
+    amo_names 'company', 'contacts'
+
+    amo_field :name
+    amo_property :email, enum: 'WORK'
+    amo_property :phone, enum: 'WORK'
+    amo_property :address
+    amo_property :web
+
+    validates :name, presence: true
+
+    def params
+      data = super
+      data[:type] = 'contact'
+      data
+    end
+  end
+end

data/lib/amorail/entities/contact.rb

@@ -0,0 +1,29 @@
+require 'amorail/entities/leadable'
+
+module Amorail
+  # AmoCRM contact entity
+  class Contact < Amorail::Entity
+    include Leadable
+    amo_names 'contacts'
+
+    amo_field :name, :company_name, :linked_company_id
+
+    amo_property :email, enum: 'WORK'
+    amo_property :phone, enum: 'MOB'
+    amo_property :position
+
+    validates :name, presence: true
+
+    # Clear company cache
+    def reload
+      @company = nil
+      super
+    end
+
+    def company
+      return if linked_company_id.nil?
+
+      @company ||= Amorail::Company.find(linked_company_id)
+    end
+  end
+end

data/lib/amorail/entities/contact_link.rb

@@ -0,0 +1,32 @@
+module Amorail
+  # AmoCRM contact-link join model
+  class ContactLink < Amorail::Entity
+    amo_names "contacts", "links"
+
+    amo_field :contact_id, :lead_id
+
+    class << self
+      # Find links by contacts ids
+      def find_by_contacts(*ids)
+        ids = ids.first if ids.size == 1 && ids.first.is_a?(Array)
+        response = client.safe_request(
+          :get,
+          remote_url('links'),
+          contacts_link: ids
+        )
+        load_many(response)
+      end
+
+      # Find links by leads ids
+      def find_by_leads(*ids)
+        ids = ids.first if ids.size == 1 && ids.first.is_a?(Array)
+        response = client.safe_request(
+          :get,
+          remote_url('links'),
+          deals_link: ids
+        )
+        load_many(response)
+      end
+    end
+  end
+end

data/lib/amorail/entities/elementable.rb

@@ -0,0 +1,37 @@
+module Amorail
+  # Provides common functionallity for entities
+  # that can be attached to another objects.
+  module Elementable
+    extend ActiveSupport::Concern
+
+    ELEMENT_TYPES = {
+      contact: 1,
+      lead:    2,
+      company: 3,
+      task:    4
+    }.freeze
+
+    included do
+      amo_field :element_id, :element_type
+
+      validates :element_id, :element_type,
+                presence: true
+    end
+
+    ELEMENT_TYPES.each do |type, value|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{type}=(val)                        # def contact=(val)
+          #{type}! if val                        #   contact! if val
+        end                                      # end
+
+        def #{type}?                             # def contact?
+          self.element_type == #{value}          #   self.element_type == 1
+        end                                      # end
+
+        def #{type}!                             # def contact!
+          self.element_type = #{value}           #   self.element_type = 1
+        end                                      # end
+      CODE
+    end
+  end
+end

data/lib/amorail/entities/lead.rb

@@ -0,0 +1,26 @@
+module Amorail
+  # AmoCRM lead entity
+  class Lead < Amorail::Entity
+    amo_names "leads"
+
+    amo_field :name, :price, :status_id, :pipeline_id, :tags
+
+    validates :name, :status_id, presence: true
+
+    def reload
+      @contacts = nil
+      super
+    end
+
+    # Return list of associated contacts
+    def contacts
+      fail NotPersisted if id.nil?
+
+      @contacts ||=
+        begin
+          links = Amorail::ContactLink.find_by_leads(id)
+          links.empty? ? [] : Amorail::Contact.find_all(links.map(&:contact_id))
+        end
+    end
+  end
+end

data/lib/amorail/entities/leadable.rb

@@ -0,0 +1,29 @@
+module Amorail
+  # Lead associations
+  module Leadable
+    extend ActiveSupport::Concern
+
+    included do
+      amo_field :linked_leads_id
+    end
+
+    # Set initial value for linked_leads_id to []
+    def initialize(*args)
+      super
+      self.linked_leads_id ||= []
+    end
+
+    # Clear leads cache on reload
+    def reload
+      @leads = nil
+      super
+    end
+
+    # Return all linked leads
+    def leads
+      return [] if linked_leads_id.empty?
+
+      @leads ||= Amorail::Lead.find_all(linked_leads_id)
+    end
+  end
+end

data/lib/amorail/entities/note.rb

@@ -0,0 +1,17 @@
+require 'amorail/entities/elementable'
+
+module Amorail
+  # AmoCRM note entity
+  class Note < Amorail::Entity
+    include Elementable
+
+    amo_names 'notes'
+
+    amo_field :note_type, :text
+
+    validates :note_type, :text,
+              presence: true
+
+    validates :element_type, inclusion: ELEMENT_TYPES.values
+  end
+end

data/lib/amorail/entities/task.rb

@@ -0,0 +1,18 @@
+require 'amorail/entities/elementable'
+
+module Amorail
+  # AmoCRM task entity
+  class Task < Amorail::Entity
+    include Elementable
+
+    amo_names 'tasks'
+
+    amo_field :task_type, :text, complete_till: :timestamp
+
+    validates :task_type, :text, :complete_till,
+              presence: true
+
+    validates :element_type, inclusion:
+              ELEMENT_TYPES.reject { |type, _| type == :task }.values
+  end
+end

data/lib/amorail/entities/webhook.rb

@@ -0,0 +1,42 @@
+module Amorail
+  # AmoCRM webhook entity
+  class Webhook < Entity
+    amo_names 'webhooks'
+
+    amo_field :id, :url, :events, :disabled
+
+    def self.list
+      response = client.safe_request(:get, remote_url('list'))
+
+      return [] if response.body.blank?
+
+      response.body['response'].fetch(amo_response_name, []).map do |attributes|
+        new.reload_model(attributes)
+      end
+    end
+
+    def self.subscribe(webhooks)
+      perform_webhooks_request('subscribe', webhooks) do |data|
+        data.map { |attrs| new.reload_model(attrs) }
+      end
+    end
+
+    def self.unsubscribe(webhooks)
+      perform_webhooks_request('unsubscribe', webhooks)
+    end
+
+    def self.perform_webhooks_request(action, webhooks, &block)
+      response = client.safe_request(
+        :post,
+        remote_url(action),
+        request: { webhooks: { action => webhooks } }
+      )
+
+      return response unless block
+
+      block.call(response.body['response'].dig(amo_response_name, 'subscribe'))
+    end
+
+    private_class_method :perform_webhooks_request
+  end
+end

data/lib/amorail/entity.rb

@@ -0,0 +1,128 @@
+require 'active_model'
+
+module Amorail
+  # Core class for all Amo entities (company, contact, etc)
+  class Entity
+    include ActiveModel::Model
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Validations
+
+    class RecordNotFound < ::Amorail::Error; end
+
+    class << self
+      attr_reader :amo_name, :amo_response_name
+
+      delegate :client, to: Amorail
+
+      # copy Amo names
+      def inherited(subclass)
+        subclass.amo_names amo_name, amo_response_name
+      end
+
+      def amo_names(name, response_name = nil)
+        @amo_name = @amo_response_name = name
+        @amo_response_name = response_name unless response_name.nil?
+      end
+
+      def amo_field(*vars, **hargs)
+        vars.each { |v| attributes[v] = :default }
+        hargs.each { |k, v| attributes[k] = v }
+        attr_accessor(*(vars + hargs.keys))
+      end
+
+      def amo_property(name, options = {})
+        properties[name] = options
+        attr_accessor(name)
+      end
+
+      def attributes
+        @attributes ||=
+          superclass.respond_to?(:attributes) ? superclass.attributes.dup : {}
+      end
+
+      def properties
+        @properties ||=
+          superclass.respond_to?(:properties) ? superclass.properties.dup : {}
+      end
+
+      def remote_url(action)
+        File.join(Amorail.config.api_path, amo_name, action)
+      end
+    end
+
+    amo_field :id, :request_id, :responsible_user_id,
+              date_create: :timestamp, last_modified: :timestamp
+
+    delegate :amo_name, :remote_url, :client, to: :class
+    delegate :properties, to: Amorail
+
+    def initialize(attributes = {})
+      super(attributes)
+      self.last_modified = Time.now.to_i if last_modified.nil?
+    end
+
+    require 'amorail/entity/params'
+    require 'amorail/entity/persistence'
+    require 'amorail/entity/finders'
+
+    def reload_model(info)
+      merge_params(info)
+      merge_custom_fields(info['custom_fields'])
+      self
+    end
+
+    private
+
+    def merge_params(attrs)
+      attrs.each do |k, v|
+        action = "#{k}="
+        next unless respond_to?(action)
+
+        send(action, v)
+      end
+      self
+    end
+
+    def merge_custom_fields(fields)
+      return if fields.nil?
+
+      fields.each do |f|
+        fname = f['code'] || f['name']
+        next if fname.nil?
+
+        fname = "#{fname.downcase}="
+        fval = f.fetch('values').first.fetch('value')
+        send(fname, fval) if respond_to?(fname)
+      end
+    end
+
+    # call safe method <safe_request>. safe_request call authorize
+    # if current session undefined or expires.
+    def push(method)
+      response = commit_request(create_params(method))
+      handle_response(response, method)
+    end
+
+    def commit_request(attrs)
+      client.safe_request(
+        :post,
+        remote_url('set'),
+        normalize_params(attrs)
+      )
+    end
+
+    # We can have response with 200 or 204 here.
+    # 204 response has no body, so we don't want to parse it.
+    def handle_response(response, method)
+      return false if response.status == 204
+
+      data = send(
+        "extract_data_#{method}",
+        response.body['response'][self.class.amo_response_name]
+      )
+      reload_model(data)
+    rescue InvalidRecord
+      false
+    end
+  end
+end