amorail 0.1.4

data/lib/amorail/entity.rb

@@ -0,0 +1,263 @@
+require 'active_model'
+
+module Amorail
+  class AmoEntity
+    include ActiveModel::Model
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Validations
+
+    class InvalidRecord < ::Amorail::Error; end
+    class NotPersisted < ::Amorail::Error; end
+    class RecordNotFound < ::Amorail::Error; end
+
+    class << self
+      attr_reader :amo_name, :amo_response_name, :attributes, :properties
+
+      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)
+        @attributes ||= {}
+        vars.each { |v| @attributes[v] = :default }
+        hargs.each { |k, v| @attributes[k] = v }
+        attr_accessor(*@attributes.keys)
+      end
+
+      def amo_property(name, options = {})
+        @properties ||= {}
+        @properties[name] = options
+        attr_accessor(name)
+      end
+
+      def find(id)
+        new.load_record(id)
+      end
+
+      def find!(id)
+        rec = find(id)
+        fail RecordNotFound unless rec
+        rec
+      end
+    end
+
+    amo_names 'entity'
+
+    amo_field :id, :request_id, :responsible_user_id,
+              date_create: :timestamp, last_modified: :timestamp
+
+    delegate :client, :properties, to: Amorail
+
+    def initialize(attributes = {})
+      super(attributes)
+      self.last_modified = Time.now.to_i if last_modified.nil?
+    end
+
+    def new_record?
+      id.blank?
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def load_record(id)
+      response = client.safe_request(
+        :get,
+        remote_url('list'),
+        id: id
+      )
+      handle_response(response, 'load')
+    end
+
+    def save
+      return false unless valid?
+      new_record? ? push('add') : push('update')
+    end
+
+    def save!
+      if save
+        true
+      else
+        fail InvalidRecord
+      end
+    end
+
+    def update(attrs = {})
+      return false if new_record?
+      merge_params(attrs)
+      push('update')
+    end
+
+    def update!(attrs = {})
+      if update(attrs)
+        true
+      else
+        fail NotPersisted
+      end
+    end
+
+    def params
+      data = {}
+      self.class.attributes.each do |k, v|
+        data[k] = send("to_#{v}", send(k))
+      end
+
+      data[:custom_fields] = custom_fields
+
+      normalize_params(data)
+    end
+
+    protected
+
+    def custom_fields
+      return unless properties.respond_to?(self.class.amo_name)
+
+      return if self.class.properties.nil?
+
+      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)
+    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
+
+    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
+
+    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.fetch('code').downcase}="
+        fval = f.fetch('values').first.fetch('value')
+        send(fname, fval) if respond_to?(fname)
+      end
+    end
+
+    def attributes_list
+      self.class.attributes
+    end
+
+    def remote_url(action)
+      File.join(Amorail.config.api_path, self.class.amo_name, action)
+    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
+
+    def handle_response(response, method)
+      if response.status == 200
+        extract_method = "extract_data_#{method}"
+        reload_model(
+          send(
+            extract_method,
+            response.body['response'][self.class.amo_response_name]
+          )
+        ) if respond_to?(extract_method, true)
+        self
+      else
+        false
+      end
+    end
+
+    def extract_data_load(response)
+      response.first
+    end
+
+    def extract_data_add(response)
+      response.fetch('add').first
+    end
+  end
+end

data/lib/amorail/exceptions.rb

@@ -0,0 +1,26 @@
+# Classes for 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 AmoNotFoudError < APIError; end
+
+  class AmoInternalError < APIError; end
+
+  class AmoBadGatewayError < APIError; end
+
+  class AmoServiceUnaviableError < APIError; end
+
+  class AmoUnknownError < APIError; end
+end

data/lib/amorail/version.rb

@@ -0,0 +1,3 @@
+module Amorail
+  VERSION = "0.1.4"
+end

data/lib/amorail.rb

@@ -0,0 +1,35 @@
+require 'amorail/version'
+require 'amorail/config'
+require 'amorail/client'
+require 'amorail/exceptions'
+require 'amorail/entity'
+require 'amorail/custom_fields'
+
+require 'amorail/entities/leadable'
+
+Gem.find_files('amorail/entities/*.rb').each { |path| require path }
+
+module Amorail
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.properties
+    @properties ||= Property.new(client)
+  end
+
+  def self.configure
+    yield(config) if block_given?
+  end
+
+  def self.client
+    @client ||= Client.new
+  end
+
+  def self.reset
+    @config = nil
+    @client = nil
+  end
+
+  require 'amorail/engine' if defined?(Rails)
+end

data/lib/tasks/amorail.rake

@@ -0,0 +1,8 @@
+require 'amorail'
+
+namespace :amorail do
+  desc "Check Amorails configuration. Authorize and get custom fields information"
+  task :check do
+    p Amorail.properties
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Amorail::Client do
+  let(:client) { Amorail.client }
+
+  before(:each) { mock_api }
+
+  it "it should create client" do
+    expect(Amorail.config.usermail).to eq "amorail@test.com"
+    expect(Amorail.config.api_key).to eq "75742b166417fe32ae132282ce178cf6"
+    expect(Amorail.config.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

data/spec/company_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Amorail::AmoCompany do
+  before { mock_api }
+  
+  describe "validations" do
+    it { should validate_presence_of(:name) }
+  end
+
+  describe "#params" do
+    let(:company) do
+      Amorail::AmoCompany.new(
+        name: 'Test inc',
+        phone: '12345678',
+        email: 'test@mala.ru',
+        address: '10, State st',
+        web: 'hoohle.com'
+      )
+    end
+
+    subject { company.params }
+
+    specify { is_expected.to include(name: 'Test inc') }
+    specify { is_expected.to include(type: 'contact') }
+
+    it "contains email property" do
+      prop = subject[:custom_fields].detect { |p| p[:id] == "1460591" }
+      expect(prop).not_to be_nil
+      expect(prop[:values].first[:value]).to eq 'test@mala.ru'
+      expect(prop[:values].first[:enum]).to eq 'WORK'
+    end
+
+    it "contains phone property" do
+      prop = subject[:custom_fields].detect { |p| p[:id] == "1460589" }
+      expect(prop).not_to be_nil
+      expect(prop[:values].first[:value]).to eq '12345678'
+      expect(prop[:values].first[:enum]).to eq 'WORK'
+    end
+
+    it "contains address property" do
+      prop = subject[:custom_fields].detect { |p| p[:id] == "1460597" }
+      expect(prop).not_to be_nil
+      expect(prop[:values].first[:value]).to eq '10, State st'
+    end
+
+    it "contains web property" do
+      prop = subject[:custom_fields].detect { |p| p[:id] == "1460593" }
+      expect(prop).not_to be_nil
+      expect(prop[:values].first[:value]).to eq 'hoohle.com'
+    end
+  end
+
+  describe "#save" do
+    let(:company) { Amorail::AmoCompany.new(name: "test") }
+
+    before { company_create_stub(Amorail.config.api_endpoint) }
+
+    it "should set id after create" do
+      company.save!
+      expect(company.id).to eq 101
+    end
+  end
+end

data/spec/contact_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+describe Amorail::AmoContact do
+  before { mock_api }
+
+  let(:contact) { Amorail::AmoContact.new(name: "test") }
+
+  describe "validations" do
+    it { should validate_presence_of(:name)}
+  end
+
+  describe "#params" do
+    let(:contact) do
+      Amorail::AmoContact.new(
+        name: 'Tester',
+        company_name: 'Test inc',
+        phone: '12345678',
+        email: 'test@mala.ru',
+        position: 'CEO'
+      )
+    end
+
+    subject { contact.params }
+
+    specify { is_expected.to include(name: 'Tester') }
+    specify { is_expected.to include(company_name: 'Test inc') }
+
+    it "contains email property" do
+      prop = subject[:custom_fields].detect { |p| p[:id] == "1460591" }
+      expect(prop).not_to be_nil
+      expect(prop[:values].first[:value]).to eq 'test@mala.ru'
+      expect(prop[:values].first[:enum]).to eq 'MOB'
+    end
+
+    it "contains phone property" do
+      prop = subject[:custom_fields].detect { |p| p[:id] == "1460589" }
+      expect(prop).not_to be_nil
+      expect(prop[:values].first[:value]).to eq '12345678'
+      expect(prop[:values].first[:enum]).to eq 'WORK'
+    end
+
+    it "contains position property" do
+      prop = subject[:custom_fields].detect { |p| p[:id] == "1460587" }
+      expect(prop).not_to be_nil
+      expect(prop[:values].first[:value]).to eq 'CEO'
+    end
+  end
+
+  describe ".find" do
+    before { contact_find_stub(Amorail.config.api_endpoint, 101) }
+    before { contact_find_stub(Amorail.config.api_endpoint, 102, false) }
+
+    it "loads entity" do
+      obj = Amorail::AmoContact.find(101)
+      expect(obj.id).to eq 101
+      expect(obj.company_name).to eq "Foo Inc."
+      expect(obj.email).to eq "foo@tb.com"
+      expect(obj.phone).to eq "1111 111 111"
+    end
+
+    it "returns nil" do
+      obj = Amorail::AmoContact.find(102)
+      expect(obj).to be_falsey
+    end
+
+    it "raise error" do
+      expect { Amorail::AmoContact.find!(102) }
+        .to raise_error(Amorail::AmoEntity::RecordNotFound)
+    end
+  end
+
+  describe "#save" do
+    before { contact_create_stub(Amorail.config.api_endpoint) }
+
+    it "set id after create" do
+      contact.save!
+      expect(contact.id).to eq 101
+    end
+  end
+
+  describe "#update" do
+    before { contact_create_stub(Amorail.config.api_endpoint) }
+
+    it "update params" do
+      contact.save!
+      contact.name = "foo"
+
+      contact_update_stub(Amorail.config.api_endpoint)
+      expect(contact.save!).to be_truthy
+      expect(contact.name).to eq "foo"
+    end
+
+    it "raise error if id is blank?" do
+      obj = Amorail::AmoContact.new
+      expect { obj.update!(name: 'Igor') }.to raise_error
+    end
+
+    it "raise error" do
+      obj = Amorail::AmoContact.new
+      expect { obj.update!(id: 101, name: "Igor") }
+        .to(raise_error)
+    end
+  end
+end

data/spec/custom_class_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "webmock/rspec"
+
+describe "spec for Amorail Properties" do
+  before(:each) { mock_api }
+
+  let(:prop) {Amorail.properties}
+
+  it "should parse companies hash" do
+    expect(prop.company.phone.present?).to be_truthy
+    expect(prop.company.phone.is_a?(Amorail::Property::PropertyItem)).to be_truthy
+    expect(prop.company.phone.id.present?).to be_truthy
+    expect(prop.company.data["phone"].data["id"]).to eq prop.company.phone.id
+
+    expect(prop.company.phone.id).to eq "1460589"
+    expect(prop.company.address.id).to eq "1460597"
+    expect(prop.company.email.id).to eq "1460591"
+    expect(prop.company.web.id).to eq "1460593"
+  end
+
+  it "should parse contacts hash" do
+    expect(prop.contacts.email.present?).to be_truthy
+    expect(prop.contacts.im.is_a?(Amorail::Property::PropertyItem)).to be_truthy
+    expect(prop.contacts.im.id.present?).to be_truthy
+    expect(prop.contacts.data["im"].data["id"]).to eq prop.contacts.im.id
+
+    expect(prop.contacts.im.id).to eq "1460595"
+    expect(prop.contacts.position.id).to eq "1460587"
+    expect(prop.contacts.phone.id).to eq "1460589"
+    expect(prop.contacts.email.id).to eq "1460591"
+  end
+
+  it "should parse leads hash" do
+    expect(prop.leads.statuses["Первичный контакт"].id).to eq "8195972"
+    expect(prop.leads.statuses["Успешно реализовано"].id).to eq "142"
+  end
+
+  it "should parse task types" do
+    expect(prop.tasks.follow_up.id).to eq 1
+    expect(prop.tasks["CALL"].id).to eq 1
+  end
+end

data/spec/entity_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Amorail::AmoEntity do
+  before { mock_api }
+
+  let(:entity) { Amorail::AmoEntity.new }
+
+  describe "#params" do
+    let(:now) { Time.now }
+
+    subject { entity.params }
+
+    specify { is_expected.to include(:last_modified) }
+    specify { is_expected.not_to include(
+      :id, :request_id, :responsible_user_id, :date_create)
+    }
+
+    context "with some values" do
+      let(:entity) do
+        Amorail::AmoEntity.new(
+          responsible_user_id: 2,
+          last_modified: now
+        )
+      end
+
+      specify { is_expected.to include(responsible_user_id: 2) }
+      specify { is_expected.to include(last_modified: now.to_i) }
+      specify { is_expected.not_to include(
+        :id, :request_id, :date_create)
+      }
+    end
+
+    context "with all values" do
+      let(:entity) do
+        Amorail::AmoEntity.new(
+          id: 100,
+          request_id: 1,
+          responsible_user_id: 2,
+          date_create: now,
+          last_modified: now
+        )
+      end
+
+      specify { is_expected.to include(id: 100) }
+      specify { is_expected.to include(request_id: 1) }
+      specify { is_expected.to include(responsible_user_id: 2) }
+      specify { is_expected.to include(date_create: now.to_i) }
+      specify { is_expected.to include(last_modified: now.to_i) }
+    end
+  end
+end