amorail 0.5.0

data/lib/amorail/entity/finders.rb

@@ -0,0 +1,67 @@
+module Amorail # :nodoc: all
+  class Entity
+    class << self
+      # Find AMO entity by id
+      def find(id)
+        new.load_record(id)
+      end
+
+      # Find AMO entity by id
+      # and raise RecordNotFound if nothing was found
+      def find!(id)
+        rec = find(id)
+        fail RecordNotFound unless rec
+
+        rec
+      end
+
+      # General method to load many records by proving some filters
+      def where(options)
+        response = client.safe_request(
+          :get,
+          remote_url('list'),
+          options
+        )
+        load_many(response)
+      end
+
+      def find_all(*ids)
+        ids = ids.first if ids.size == 1 && ids.first.is_a?(Array)
+
+        where(id: ids)
+      end
+
+      # Find AMO entities by query
+      # Returns array of matching entities.
+      def find_by_query(query)
+        where(query: query)
+      end
+
+      private
+
+      # We can have response with 200 or 204 here.
+      # 204 response has no body, so we don't want to parse it.
+      def load_many(response)
+        return [] if response.status == 204
+
+        response.body['response'].fetch(amo_response_name, [])
+                .map { |info| new.reload_model(info) }
+      end
+    end
+
+    def load_record(id)
+      response = client.safe_request(
+        :get,
+        remote_url('list'),
+        id: id
+      )
+      handle_response(response, 'load') || nil
+    end
+
+    private
+
+    def extract_data_load(response)
+      response.first
+    end
+  end
+end

data/lib/amorail/entity/params.rb

@@ -0,0 +1,95 @@
+require "active_support/core_ext/hash/indifferent_access"
+
+module Amorail # :nodoc: all
+  class Entity
+    def params
+      data = {}
+      self.class.attributes.each do |k, v|
+        data[k] = send("to_#{v}", send(k))
+      end
+
+      data[:custom_fields] = custom_fields if properties.respond_to?(amo_name)
+
+      normalize_params(data)
+    end
+
+    protected
+
+    def custom_fields
+      props = properties.send(self.class.amo_name)
+
+      custom_fields = []
+
+      self.class.properties.each do |k, v|
+        prop_id = props.send(k).id
+        prop_val = { value: send(k) }.merge(v)
+        custom_fields << { id: prop_id, values: [prop_val] }
+      end
+
+      custom_fields
+    end
+
+    def create_params(method)
+      {
+        request: {
+          self.class.amo_response_name => {
+            method => [
+              params
+            ]
+          }
+        }
+      }
+    end
+
+    def normalize_custom_fields(val)
+      val.reject do |field|
+        field[:values].all? { |item| !item[:value] }
+      end
+    end
+
+    # this method removes nil values and empty arrays from params hash (deep)
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    def normalize_params(data)
+      return data unless data.is_a?(Hash)
+
+      compacted = {}
+      data.each do |key, val|
+        case val
+        when Numeric, String
+          compacted[key] = val
+        when Array
+          val.compact!
+          # handle custom keys
+          val = normalize_custom_fields(val) if key == :custom_fields
+          unless val.empty?
+            compacted[key] = val.map { |el| normalize_params(el) }
+          end
+        else
+          params = normalize_params(val)
+          compacted[key] = params unless params.nil?
+        end
+      end
+      compacted.with_indifferent_access
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+
+    def to_timestamp(val)
+      return if val.nil?
+
+      case val
+      when String
+        (date = Time.parse(val)) && date.to_i
+      when Date
+        val.to_time.to_i
+      else
+        val.to_i
+      end
+    end
+
+    def to_default(val)
+      val
+    end
+  end
+end

data/lib/amorail/entity/persistence.rb

@@ -0,0 +1,66 @@
+module Amorail # :nodoc: all
+  class Entity
+    class InvalidRecord < ::Amorail::Error; end
+    class NotPersisted < ::Amorail::Error; end
+
+    def new_record?
+      id.blank?
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def save
+      return false unless valid?
+
+      new_record? ? push('add') : push('update')
+    end
+
+    def save!
+      save || fail(InvalidRecord)
+    end
+
+    def update(attrs = {})
+      return false if new_record?
+
+      merge_params(attrs)
+      push('update')
+    end
+
+    def update!(attrs = {})
+      update(attrs) || fail(NotPersisted)
+    end
+
+    def reload
+      fail NotPersisted if id.nil?
+
+      load_record(id)
+    end
+
+    private
+
+    def extract_data_add(response)
+      response.fetch('add').first
+    end
+
+    # Update response can have status 200 and contain errors.
+    # In case of errors "update" key in a response is a Hash with "errors" key.
+    # If there are no errors "update" key is an Array with entities attributes.
+    def extract_data_update(response)
+      case data = response.fetch('update')
+      when Array
+        data.first
+      when Hash
+        merge_errors(data)
+        raise(InvalidRecord)
+      end
+    end
+
+    def merge_errors(data)
+      data.fetch("errors").each do |_, message|
+        errors.add(:base, message)
+      end
+    end
+  end
+end

data/lib/amorail/exceptions.rb

@@ -0,0 +1,25 @@
+# Amorail Exceptions.
+# Every class is name of HTTP response error code(status)
+module Amorail
+  class Error < ::StandardError; end
+
+  class APIError < Error; end
+
+  class AmoBadRequestError < APIError; end
+
+  class AmoMovedPermanentlyError < APIError; end
+
+  class AmoUnauthorizedError < APIError; end
+
+  class AmoForbiddenError < APIError; end
+
+  class AmoNotFoundError < APIError; end
+
+  class AmoInternalError < APIError; end
+
+  class AmoBadGatewayError < APIError; end
+
+  class AmoServiceUnaviableError < APIError; end
+
+  class AmoUnknownError < APIError; end
+end

data/lib/amorail/property.rb

@@ -0,0 +1,130 @@
+module Amorail
+  # Return hash key as method call
+  module MethodMissing
+    def method_missing(method_sym, *arguments, &block)
+      if data.key?(method_sym.to_s)
+        data.fetch(method_sym.to_s)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_sym, *args)
+      args.size.zero? && data.key?(method_sym.to_s)
+    end
+  end
+
+  class Property # :nodoc: all
+    class PropertyItem
+      include MethodMissing
+
+      class << self
+        attr_accessor :source_name
+
+        def parse(data)
+          hash = {}
+          data['custom_fields'].fetch(source_name, []).each do |contact|
+            identifier = contact['code'].presence || contact['name'].presence
+            next if identifier.nil?
+
+            hash[identifier.downcase] = PropertyItem.new(contact)
+          end
+          new hash
+        end
+      end
+
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def [](key)
+        @data[key]
+      end
+    end
+
+    class StatusItem
+      attr_reader :statuses
+
+      def initialize(data)
+        @statuses = data
+      end
+    end
+
+    attr_reader :client, :data, :contacts,
+                :company, :leads, :tasks
+
+    def initialize(client)
+      @client = client
+      reload
+    end
+
+    def reload
+      @data = load_fields
+      parse_all_data
+    end
+
+    def load_fields
+      response = client.safe_request(
+        :get,
+        '/private/api/v2/json/accounts/current'
+      )
+      response.body["response"]["account"]
+    end
+
+    def inspect
+      @data
+    end
+
+    private
+
+    def parse_all_data
+      @contacts = Contact.parse(data)
+      @company = Company.parse(data)
+      @leads = Lead.parse(data)
+      @tasks = Task.parse(data)
+    end
+
+    class Contact < PropertyItem
+      self.source_name = 'contacts'
+    end
+
+    class Company < PropertyItem
+      self.source_name = 'companies'
+    end
+
+    class Lead < PropertyItem
+      self.source_name = 'leads'
+
+      attr_accessor :statuses
+
+      class << self
+        def parse(data)
+          obj = super
+          hash = {}
+          data.fetch('leads_statuses', []).each do |prop|
+            hash[prop['name']] = PropertyItem.new(prop)
+          end
+          obj.statuses = hash
+          obj
+        end
+      end
+    end
+
+    class Task < PropertyItem
+      def self.parse(data)
+        hash = {}
+        data.fetch('task_types', []).each do |tt|
+          prop_item = PropertyItem.new(tt)
+          identifier = tt['code'].presence || tt['name'].presence
+          next if identifier.nil?
+
+          hash[identifier.downcase] = prop_item
+          hash[identifier] = prop_item
+        end
+        new hash
+      end
+    end
+  end
+end

data/lib/amorail/railtie.rb

@@ -0,0 +1,8 @@
+module Amorail
+  # Add amorail rake tasks
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../tasks/amorail.rake', __dir__)
+    end
+  end
+end

data/lib/amorail/version.rb

@@ -0,0 +1,4 @@
+# Amorail version
+module Amorail
+  VERSION = "0.5.0".freeze
+end

data/lib/tasks/amorail.rake

@@ -0,0 +1,6 @@
+namespace :amorail do
+  desc 'Check Amorail configuration'
+  task :check do
+    puts Amorail.properties.inspect
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe Amorail::Client do
+  let(:client) { Amorail.client }
+
+  before(:each) { mock_api }
+
+  context "default client" do
+    it "should create client", :aggregate_failures do
+      expect(subject.usermail).to eq "amorail@test.com"
+      expect(subject.api_key).to eq "75742b166417fe32ae132282ce178cf6"
+      expect(subject.api_endpoint).to eq "https://test.amocrm.ru"
+    end
+
+    it "should #authorize method call" do
+      res = client.authorize
+      expect(res.status).to eq 200
+    end
+
+    it "should #authorize and set cookie" do
+      res = client.get("/private/api/v2/json/accounts/current")
+      expect(res.status).to eq 200
+    end
+  end
+
+  describe "#with_client" do
+    before { mock_custom_api("https://custom.amo.com", "custom@amo.com", "123") }
+
+    let(:new_client) do
+      described_class.new(
+        api_endpoint: "https://custom.amo.com",
+        usermail: "custom@amo.com",
+        api_key: "123"
+      )
+    end
+
+    it "use custom client as instance", :aggregate_failures do
+      expect(Amorail.client.usermail).to eq "amorail@test.com"
+      Amorail.with_client(new_client) do
+        expect(Amorail.client.usermail).to eq "custom@amo.com"
+        expect(Amorail.client.api_endpoint).to eq "https://custom.amo.com"
+        expect(Amorail.client.api_key).to eq "123"
+      end
+
+      expect(Amorail.client.usermail).to eq "amorail@test.com"
+    end
+
+    it "use custom client as options", :aggregate_failures do
+      expect(Amorail.client.usermail).to eq "amorail@test.com"
+      Amorail.with_client(
+        api_endpoint: "https://custom.amo.com",
+        usermail: "custom@amo.com",
+        api_key: "123"
+      ) do
+        expect(Amorail.client.usermail).to eq "custom@amo.com"
+        expect(Amorail.client.api_endpoint).to eq "https://custom.amo.com"
+        expect(Amorail.client.api_key).to eq "123"
+      end
+
+      expect(Amorail.client.usermail).to eq "amorail@test.com"
+    end
+
+    it "loads custom properties", :aggregate_failures do
+      expect(Amorail.properties.company.phone.id).to eq "1460589"
+
+      Amorail.with_client(new_client) do
+        expect(Amorail.properties.company.phone.id).to eq "301"
+      end
+
+      expect(Amorail.properties.company.phone.id).to eq "1460589"
+    end
+
+    it "threadsafe", :aggregate_failures do
+      results = []
+      q1 = Queue.new
+      q2 = Queue.new
+      q3 = Queue.new
+      threads = []
+
+      # This thread enters block first but commits result
+      # only after the second thread enters block
+      threads << Thread.new do
+        q1.pop
+        Amorail.with_client(usermail: 'test1@amo.com') do
+          q2 << 1
+          q1.pop
+          results << Amorail.client.usermail
+          q2 << 1
+        end
+        q3 << 1
+      end
+
+      # This thread enters block second and commits result
+      # after the first block
+      threads << Thread.new do
+        q2.pop
+        Amorail.with_client(usermail: 'test2@amo.com') do
+          q1 << 1
+          q2.pop
+          results << Amorail.client.usermail
+        end
+        q3 << 1
+      end
+
+      # This thread enters block third and commits
+      # after all other threads left blocks
+      threads << Thread.new do
+        Amorail.with_client(usermail: 'test3@amo.com') do
+          q3.pop
+          q3.pop
+          results << Amorail.client.usermail
+        end
+      end
+
+      q1 << 1
+      threads.each(&:join)
+
+      expect(results[0]).to eq 'test1@amo.com'
+      expect(results[1]).to eq 'test2@amo.com'
+      expect(results[2]).to eq 'test3@amo.com'
+    end
+  end
+end