Переходим на страницу интеграций https://yourdomain.amocrm.ru/settings/widgets/ и нажимаем "+ СОЗДАТЬ ИНТЕГРАЦИЮ"
Заполняем поля, в первое поле вводим https://yourdomain.com/amocrm и нажимаем "Сохранить"
Переходим на таб "Ключи и доступы". Код авторизации работает 20 минут.

В файл config/amocrm.yml вставляем данные.

Авторизация через перенаправления пользователя (требуется gem Devise)

Выполняем все шаги как при упрощенной авторизации

Ссылка на получение кода:

<%= link_to "Установить интеграцию",
          amocrm_oauth_url(state: current_user.try(:id)),
          class: 'btn btn-primary' %>

Пример доступен по адресу: https://yourdomain/amocrm/link

alt Страница с кнопкой

Нажимаем на кнопку, логинимся в амо и даём права приложению

alt Авторизация в amo

После вы будуте перенаправлены на страницу https://yourdomain.com/amocrm

alt Страница с кнопкой

Если вы увидили код и информацию об аккаунте - всё в порядке, копировать код нет необходимости, страницу можно закрыть.

Если вы не используете gem Devise, то вам необходимо реализовать в application_controller.rb методы current_user для получения текущего пользователя, user_signed_in? для проверки авторизован ли посетитель на вашем сайте и new_user_session_path для получения пути к странице авторизции.

Вы можете изменять timeout, open_timeout, faraday_adapter, proxy, symbolize_keys, logger, и debug:

AmocrmRails::Request.timeout = 60
AmocrmRails::Request.open_timeout = 60
AmocrmRails::Request.symbolize_keys = true
AmocrmRails::Request.debug = false

в файле config/initializers/amocrm.rb

Параметры аккаунта

params = {
  with: 'amojo_id,amojo_rights,users_groups,task_types,version,entity_names,datetime_settings'
}
response = AmocrmRails::Request.account.retrieve(params: params)
p(response.body)

Сделки

Список сделок

params = {
  with: 'catalog_elements',
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.leads.retrieve(params: params)
p(response.body)
leads = response.body[:_embedded][:leads]
lead_id = leads.first[:id]

Получение сделки по ID

params = {
  with: 'catalog_elements'
}
response = AmocrmRails::Request.leads(lead_id).retrieve(params: params)
p(response.body)

Добавление сделок

body = [
    {
        "name": "Сделка для примера 1",
        "created_by": 0,
        "price": 20000
    },
    {
        "name": "Сделка для примера 2",
        "price": 10000
    }
]
response = AmocrmRails::Request.leads.create(body: body)
p(response.body)
leads = response.body[:_embedded][:leads]

Комплексное добавление сделок с контактом и компанией

body = [
  {
    name: "Название сделки",
    price: 3422,
    created_at: 1608905348
  },
  {
    name: "Название сделки",
    price: 3422
  }
]
response = AmocrmRails::Request.leads.complex.create(body: body)
p(response.body)

Редактирование сделок

body = [
    {
      id: 666749,
      closed_at: 1589297221
    },
    {
      id: 666753,
      price: 50000
    }
]
response = AmocrmRails::Request.leads.update(body: body)
p(response.body)
leads = response.body[:_embedded][:leads]

Редактирование сделки

body = {
  closed_at: 1589297221
}
response = AmocrmRails::Request.leads(666749).update(body: body)
p(response.body)
leads = response.body[:_embedded][:leads]

Неразобранное

Список неразобранного

params = {
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.leads.unsorted.retrieve(params: params)
p(response.body)
unsorted = response.body[:_embedded][:unsorted]
uid = unsorted.first[:uid]

Получение неразобранного по UID

response = AmocrmRails::Request.leads.unsorted(uid).retrieve
p(response.body)

Добавление неразобранного типа звонок

body = [
  {
    source_name: "ООО Деппа",
    source_uid: "a1fee7c0fc436088e64ba2e8822ba2b3",
    created_at: 1510261200,
    _embedded: {
      leads: [
        {
          name: "Тех обслуживание",
          price: 5000
        }
      ],
      contacts: [
        {
          name: "Контакт для примера"
        }
      ],
      companies: [
        {
          name: "ООО Деппа"
        }
      ]
    },
    metadata: {
      is_call_event_needed: true,
      uniq: "a1fe231cc88e64ba2e8822ba2b3ewrw",
      duration: 54,
      service_code: "CkAvbEwPam6sad",
      link: "https://deppa.ru",
      phone: 79998888888,
      called_at: 1510261200,
      from: "onlinePBX"
    }
  }
]
response = AmocrmRails::Request.leads.unsorted.sip.create(body: body)
p(response.body)

Добавление неразобранного типа форма

body = [
  {
    source_name: "ООО Деппа",
    source_uid: "a1fee7c0fc436088e64ba2e8822ba2b3",
    created_at: 1590830520,
    _embedded: {
      leads: [
        {
          name: "Тех обслуживание",
          visitor_uid: "5692210d-58d0-468c-acb2-dce7f93eef87",
          price: 5000,
          _embedded: {
            tags: [
              {
                name: "Тег для примера"
              }
            ]
          }
        }
      ],
      contacts: [
        {
          name: 234,
          first_name: "123213",
          last_name: 234,
          custom_fields_values: [
            {
              field_code: "PHONE",
              values: [
                {
                  value: "+7912321323"
                }
              ]
            }
          ]
        }
      ],
      companies: [
        {
          name: "ООО Деппа"
        }
      ]
    },
    metadata: {
      ip: "123.222.2.22",
      form_id: "a1fee7c0fc436088e64ba2e8822ba2b3ewrw",
      form_sent_at: 1590830520,
      form_name: "Форма заявки для полёта в космос",
      form_page: "https://deppa.ru",
      referer: "https://www.google.com/search?&q=elon+musk"
    }
  }
]
response = AmocrmRails::Request.leads.unsorted.forms.create(body: body)
p(response.body)
uid = response.body[:_embedded][:unsorted].first[:uid]

Принятие неразобранного

body = {
  status_id: 41504311
}
response = AmocrmRails::Request.leads.unsorted(uid).accept.create(body: body)
p(response.body)

Отклонение неразобранного

response = AmocrmRails::Request.leads.unsorted(uid).decline.delete
p(response.body)

Привязка неразобранного

body = {
  link: {
    entity_id: lead_id,
    entity_type: "leads"
  }
}
response = AmocrmRails::Request.leads.unsorted(uid).link.create(body: body)
p(response.body)

Сводная информация о неразобранных сделках

response = AmocrmRails::Request.leads.unsorted.summary.retrieve
p(response.body)

Описание объектов metadata

Воронки и этапы

Общая информация

Список воронок сделок

response = AmocrmRails::Request.leads.pipelines.retrieve
p(response.body)
pipelines = response.body[:_embedded][:pipelines]
pipeline_id = pipelines.first[:id]

Получение воронки сделок по ID

response = AmocrmRails::Request.leads.pipelines(pipeline_id).retrieve
p(response.body)

Добавление воронок

body = [
  {
    name: "Воронка доп продаж",
    is_main: false,
    is_unsorted_on: true,
    sort: 20,
    request_id: "123",
    _embedded: {
      statuses: [
        {
          id: 142,
          name: "Мое название для успешных сделок"
        },
        {
          name: "Первичный контакт",
          sort: 10,
          color: "#fffeb2"
        }
      ]
    }
  }
]
response = AmocrmRails::Request.leads.pipelines.create(body: body)
p(response.body)
pipelines = response.body[:_embedded][:pipelines]
pipeline_id = pipelines.first[:id]

Редактирование воронки

body = {
        "name": "Новое название для воронки",
        "is_main": false,
        "is_unsorted_on": false,
        "sort": 100
}
response = AmocrmRails::Request.leads.pipelines(pipeline_id).update(body: body)
p(response.body)

Удаление воронки

AmocrmRails::Request.leads.pipelines(pipeline_id).delete

Список статусов воронки сделок

response = AmocrmRails::Request.leads.pipelines(pipeline_id).statuses.retrieve
p(response.body)
statuses = response.body[:_embedded][:statuses]
status_id = statuses.first[:id]

Получение статуса воронки сделок по ID

response = AmocrmRails::Request.leads.pipelines(pipeline_id).statuses(status_id).retrieve
p(response.body)

Добавление статусов в воронку

body = [
  {
    name: "Новый этап",
    sort: 100,
    color: "#fffeb2"
  },
  {
    name: "Новый этап 2",
    sort: 200,
    color: "#fffeb2"
  }
]
response = AmocrmRails::Request.leads.pipelines(pipeline_id).statuses.create(body: body)
p(response.body)
statuses = response.body[:_embedded][:statuses]
status_id = statuses.first[:id]

Редактирование статуса воронки

body = {
  name: "Новое название для статуса",
  color: "#c1e0ff"
}
response = AmocrmRails::Request.leads.pipelines(pipeline_id).statuses(status_id).update(body: body)
p(response.body)

Удаление статуса воронки

AmocrmRails::Request.leads.pipelines(pipeline_id).statuses(status_id).delete

Доступные цвета статусов

Фильтрация

Фильтрация списка сделок

params = {
  filter: { 
    id: lead_id
  }
}
response = AmocrmRails::Request.leads.retrieve(params: params)
p(response.body)
leads = response.body[:_embedded][:leads]

Фильтрация списка контактов

params = {
  filter: { 
    name: "Павел Осетров"
  }
}
response = AmocrmRails::Request.contacts.retrieve(params: params)
p(response.body)
contacts = response.body[:_embedded][:contacts]

Фильтрация списка компаний

params = {
  filter: { 
    name: "ООО Деппа"
  }
}
response = AmocrmRails::Request.companies.retrieve(params: params)
p(response.body)
companies = response.body[:_embedded][:companies]

Фильтрация списка покупателей

params = {
  filter: { 
    name: "Павел Осетров"
  }
}
response = AmocrmRails::Request.customers.retrieve(params: params)
p(response.body)
customers = response.body[:_embedded][:customers]

Типы фильтров

Контакты

Список контактов

params = {
  with: 'leads',
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.contacts.retrieve(params: params)
p(response.body)
contacts = response.body[:_embedded][:contacts]
contact_id = contacts.first[:id]

Получение контакта по ID

response = AmocrmRails::Request.contacts(contact_id).retrieve
p(response.body)

Добавление контактов

body = [
  {
    first_name: "Петр",
    last_name: "Смирнов"
  },
  {
    name: "Владимир Смирнов"
  }
]
response = AmocrmRails::Request.contacts.create(body: body)
p(response.body)
contacts = response.body[:_embedded][:contacts]
contact_id = contacts.first[:id]

Редактирование контактов

body = [
  {
    id: contact_id,
    first_name: "Иван",
    last_name: "Иванов"
  }
]
response = AmocrmRails::Request.contacts.update(body: body)
p(response.body)
contacts = response.body[:_embedded][:contacts]
contact_id = contacts.first[:id]

Редактирование контакта

body = {
  first_name: "Иван",
  last_name: "Иванов"
}
response = AmocrmRails::Request.contacts(contact_id).update(body: body)
p(response.body)

Привязка чатов к контактам

body = [
  {
    contact_id: contact_id,
    chat_id: uid
  }
]
response = AmocrmRails::Request.contacts.chats.create(body: body)
p(response.body)

Получение списка чатов контакта

params = [
  {
    contact_id: contact_id
  }
]
response = AmocrmRails::Request.contacts.chats.retrieve(params: params)
p(response.body)

Компании

Список компаний

params = {
  with: 'leads',
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.companies.retrieve(params: params)
p(response.body)
companies = response.body[:_embedded][:companies]
company_id = companies.first[:id]

Получение компании по ID

response = AmocrmRails::Request.companies(company_id).retrieve
p(response.body)

Добавление компаний

body = [
  { 
    name: "ООО Деппа"
  }
]
response = AmocrmRails::Request.companies.create(body: body)
p(response.body)
companies = response.body[:_embedded][:companies]
company_id = companies.first[:id]

Редактирование компаний

body = [
  { 
    id: company_id,     
    name: "ООО ДЕППА"
  }
]
response = AmocrmRails::Request.companies.update(body: body)
p(response.body)
companies = response.body[:_embedded][:companies]
company_id = companies.first[:id]

Редактирование компании

body = {
  name: "ООО ДЕППА"
}
response = AmocrmRails::Request.companies(company_id).update(body: body)
p(response.body)
company_id = response.body[:id]

Списки

Доступные списки

params = {
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.catalogs.retrieve(params: params)
p(response.body)
catalogs = response.body[:_embedded][:catalogs]
catalog_id = catalogs.first[:id]

Получение списка по ID

response = AmocrmRails::Request.catalogs(catalog_id).retrieve
p(response.body)

Добавление списков

body = [
  {
    name: "Тестовый список",
    can_add_elements: true,
    can_link_multiple: false
  }
]
response = AmocrmRails::Request.catalogs.create(body: body)
p(response.body)
catalogs = response.body[:_embedded][:catalogs]
catalog_id = catalogs.first[:id]

Редактирование списков

body = [
  { 
    id: catalog_id,     
    name: "Новое имя списка"
  }
]
response = AmocrmRails::Request.catalogs.update(body: body)
p(response.body)
catalogs = response.body[:_embedded][:catalogs]
catalog_id = catalogs.first[:id]

Редактирование списка

body = {
  name: "Новое имя списка"
}
response = AmocrmRails::Request.catalogs(catalog_id).update(body: body)
p(response.body)
catalog_id = response.body[:id]

Доступные элементы списка

params = { 
  with: 'invoice_link',      
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.catalogs(catalog_id).elements.retrieve(params: params)
p(response.body)
elements = response.body[:_embedded][:elements]
element_id = elements.first[:id]

Получение элемента списка по ID

params = { 
  with: 'invoice_link'
}
response = AmocrmRails::Request.catalogs(catalog_id).elements(element_id).retrieve(params: params)
p(response.body)
element_id = response.body[:id]

Добавление элементов списков

body = [
  {
    name: "Новый элемент списка"
  }
]
response = AmocrmRails::Request.catalogs(catalog_id).elements.create(body: body)
p(response.body)
elements = response.body[:_embedded][:elements]
element_id = elements.first[:id]

Редактирование элементов списков

body = [
  { 
    id: element_id,
    name: "Новое имя элемента"
  }
]
response = AmocrmRails::Request.catalogs(catalog_id).elements.update(body: body)
p(response.body)
elements = response.body[:_embedded][:elements]
element_id = elements.first[:id]

Редактирование элемента списка

body = { 
  name: "Новое имя элемента"
}
response = AmocrmRails::Request.catalogs(catalog_id).elements(element_id).update(body: body)
p(response.body)
element_id = response.body[:id]

Связи сущностей

Список связанных сущностей

response = AmocrmRails::Request.leads(lead_id).links.retrieve
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.contacts(contact_id).links.retrieve
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.companies(company_id).links.retrieve
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.customers(customer_id).links.retrieve
links = response.body[:_embedded][:links]

Привязка сущностей

body = [
 {
   to_entity_id: 10,
   to_entity_type: "catalog_elements",
   metadata: {
     quantity: 1,
     catalog_id: 1026
  }
 },
 {
   to_entity_id: 457282,
   to_entity_type: "contacts",
   metadata: {
     is_main: true,
  }
 }
]

response = AmocrmRails::Request.leads(lead_id).link.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.contacts(contact_id).link.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.companies(company_id).link.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.customers(customer_id).link.create(body: body)
links = response.body[:_embedded][:links]

Отвязка сущностей

body = [
  {
    to_entity_id: 10,
    to_entity_type: "catalog_elements",
    metadata: {
      catalog_id: 1026
    }
  },
  {
    to_entity_id: 457282,
    to_entity_type: "contacts",
  }
]

response = AmocrmRails::Request.leads(lead_id).unlink.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.contacts(contact_id).unlink.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.companies(company_id).unlink.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.customers(customer_id).unlink.create(body: body)
links = response.body[:_embedded][:links]

Массовый список связанных сущностей

response = AmocrmRails::Request.leads.links.retrieve
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.contacts.links.retrieve
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.companies.links.retrieve
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.customers.links.retrieve
links = response.body[:_embedded][:links]

Массовая привязка сущностей

body = [
  {
    entity_id: 14158851,
    to_entity_id: 10,
    to_entity_type: "catalog_elements",
    metadata: {
      quantity: 1,
      catalog_id: 1026
    }
  },
  {
    entity_id: 14158852,
    to_entity_id: 457282,
    to_entity_type: "contacts",
    metadata: {
      is_main: true,
    }
  }
]

response = AmocrmRails::Request.leads.link.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.contacts.link.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.companies.link.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.customers.link.create(body: body)
links = response.body[:_embedded][:links]

Массовая отвязка сущностей

body = [
  {
    to_entity_id: 10,
    to_entity_type: "catalog_elements",
    metadata: {
      catalog_id: 1026
    }
  },
  {
    to_entity_id: 457282,
    to_entity_type: "contacts",
  }
]

response = AmocrmRails::Request.leads.unlink.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.contacts.unlink.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.companies.unlink.create(body: body)
links = response.body[:_embedded][:links]

response = AmocrmRails::Request.customers.unlink.create(body: body)
links = response.body[:_embedded][:links]

Задачи

Список задач

params = {
        page: 0,
        limit: 10
}
response = AmocrmRails::Request.tasks.retrieve(params: params)
p(response.body)
tasks = response.body[:_embedded][:tasks]
task_id = tasks.first[:id]

Получение задачи по ID

response = AmocrmRails::Request.tasks(task_id).retrieve
p(response.body)
task_id = response.body[:id]

Добавление задач

body = [
 {
   task_type_id: 1,
   text: "Встретиться с клиентом Иван Иванов",
   complete_till: 1588885140
 }
]
response = AmocrmRails::Request.tasks.create(body: body)
p(response.body)
tasks = response.body[:_embedded][:tasks]

Редактирование задач

body = [
    {
      id: task_id,
      task_type_id: 2,
      text: "Новое название для задачи",
      complete_till: 1588885140
    }
]
response = AmocrmRails::Request.tasks.update(body: body)
p(response.body)
tasks = response.body[:_embedded][:tasks]

Редактирование задачи

body = {
  task_type_id: 2,
  text: "Новое название для задачи",
  complete_till: 1588885140
}
response = AmocrmRails::Request.tasks(task_id).update(body: body)
task = response.body

Выполнение задачи

body = {
  is_completed: true,
  result: {
    text: "Удалось связаться с клиентом"
  }
}
response = AmocrmRails::Request.tasks(task_id).update(body: body)
task = response.body

Поля и группы полей

Список полей сущности

response = AmocrmRails::Request.leads.custom_fields.retrieve

response = AmocrmRails::Request.contacts.custom_fields.retrieve

response = AmocrmRails::Request.companies.custom_fields.retrieve

response = AmocrmRails::Request.customers.custom_fields.retrieve

response = AmocrmRails::Request.customers.segments.custom_fields.retrieve

response = AmocrmRails::Request.catalogs(catalog_id).custom_fields.retrieve

custom_fields = response.body[:_embedded][:custom_fields]

Получение поля сущности по его ID

response = AmocrmRails::Request.leads.custom_fields(id).retrieve

response = AmocrmRails::Request.contacts.custom_fields(id).retrieve

response = AmocrmRails::Request.companies.custom_fields(id).retrieve

response = AmocrmRails::Request.customers.custom_fields(id).retrieve

response = AmocrmRails::Request.customers.segments.custom_fields(id).retrieve

response = AmocrmRails::Request.catalogs(catalog_id).custom_fields(id).retrieve

custom_fields = response.body

Создание дополнительных полей сущности

body = [
 {
   name: "multi select",
   type: "multiselect",
   sort: 510,
   required_statuses: [
   {
     pipeline_id: 16056,
     status_id: 20540473
   }
  ],
   enums: [
   {
     value: "Значение 1",
     sort: 1
   },
   {
     value: "Значение 2",
     sort: 2
   }
  ]
 }
]

response = AmocrmRails::Request.leads.custom_fields.create(body: body)

response = AmocrmRails::Request.contacts.custom_fields.create(body: body)

response = AmocrmRails::Request.companies.custom_fields.create(body: body)

response = AmocrmRails::Request.customers.custom_fields.create(body: body)

response = AmocrmRails::Request.customers.segments.custom_fields.create(body: body)

response = AmocrmRails::Request.catalogs(catalog_id).custom_fields.create(body: body)

custom_fields = response.body[:_embedded][:custom_fields]

Редактирование дополнительных полей сущности

custom_field_id = 1278898087
body_items = [{
        "id": custom_field_id,
        "name": "Новое имя для дополнительного поля",
        "sort": 560,
        "is_visible": false,
        "is_required": true
}]
body_item = {
        "name": "Новое имя для дополнительного поля",
        "sort": 560,
        "is_visible": false,
        "is_required": true
}

AmocrmRails::Request.leads.custom_fields.update(body: body_items)
AmocrmRails::Request.leads.custom_fields(custom_field_id).update(body: body_item)

AmocrmRails::Request.contacts.custom_fields.update(body: body_items)
AmocrmRails::Request.contacts.custom_fields(custom_field_id).update(body: body_item)

AmocrmRails::Request.companies.custom_fields.update(body: body_items)
AmocrmRails::Request.companies.custom_fields(custom_field_id).update(body: body_item)

AmocrmRails::Request.customers.custom_fields.update(body: body_items)
AmocrmRails::Request.customers.custom_fields(custom_field_id).update(body: body_item)

AmocrmRails::Request.customers.segments.custom_fields.update(body: body_items)
AmocrmRails::Request.customers.segments.custom_fields(custom_field_id).update(body: body_item)

AmocrmRails::Request.catalogs(catalog_id).custom_fields.update(body: body_items)
AmocrmRails::Request.catalogs(catalog_id).custom_fields(custom_field_id).update(body: body_item)

Удаление дополнительного поля

AmocrmRails::Request.leads.custom_fields(custom_field_id).delete

AmocrmRails::Request.contacts.custom_fields(custom_field_id).delete

AmocrmRails::Request.companies.custom_fields(custom_field_id).delete

AmocrmRails::Request.customers.custom_fields(custom_field_id).delete

AmocrmRails::Request.customers.segments.custom_fields(custom_field_id).delete

AmocrmRails::Request.catalogs(catalog_id).custom_fields(custom_field_id).delete

Список групп полей сущности

response = AmocrmRails::Request.leads.custom_fields.groups.retrieve

response = AmocrmRails::Request.contacts.custom_fields.groups.retrieve

response = AmocrmRails::Request.companies.custom_fields.groups.retrieve

response = AmocrmRails::Request.customers.custom_fields.groups.retrieve

custom_field_groups = response[:_embedded][:custom_field_groups]
group_id = custom_field_groups.first[:id]

Получение группы полей сущности по ID группы

response = AmocrmRails::Request.leads.custom_fields.groups(group_id).retrieve

response = AmocrmRails::Request.contacts.custom_fields.groups(group_id).retrieve

response = AmocrmRails::Request.companies.custom_fields.groups(group_id).retrieve

response = AmocrmRails::Request.customers.custom_fields.groups(group_id).retrieve

group_id = response[:id]

Создание групп полей

body = [
  {
    name: "group 1",
    sort: 4
  },
  {
    name: "group 2",
    sort: 5
  }
]

response = AmocrmRails::Request.leads.custom_fields.groups.create(body: body)

response = AmocrmRails::Request.contacts.custom_fields.groups.create(body: body)

response = AmocrmRails::Request.companies.custom_fields.groups.create(body: body)

response = AmocrmRails::Request.customers.custom_fields.groups.create(body: body)

custom_field_groups = response.body[:_embedded][:custom_field_groups]
custom_field_group_id = custom_field_groups.first[:id]

Редактирование группы полей

body = {
  sort: 6,
  fields: [
    14563,
    12575
  ]
}

response = AmocrmRails::Request.leads.custom_fields.groups(custom_field_group_id).update(body: body)

response = AmocrmRails::Request.contacts.custom_fields.groups(custom_field_group_id).update(body: body)

response = AmocrmRails::Request.companies.custom_fields.groups(custom_field_group_id).update(body: body)

response = AmocrmRails::Request.customers.custom_fields.groups(custom_field_group_id).update(body: body)

custom_field_groups = response.body[:_embedded][:custom_field_groups]
custom_field_group_id = custom_field_groups.first[:id]

Удаление группы дополнительных полей

AmocrmRails::Request.leads.custom_fields.groups(custom_field_group_id).delete

AmocrmRails::Request.contacts.custom_fields.groups(custom_field_group_id).delete

AmocrmRails::Request.companies.custom_fields.groups(custom_field_group_id).delete

AmocrmRails::Request.customers.custom_fields.groups(custom_field_group_id).delete

Доступные типы полей

Примеры заполнения разных типов полей через API

События и примечания

Список событий

params = {
  with: 'contact_name',
  page: 0,
  limit: 10
}

response = AmocrmRails::Request.events.retrieve(params: params)
events = response.body[:_embedded][:events]
event_id = events.first[:id]

Получение события по ID

params = {
  with: 'contact_name'
}

response = AmocrmRails::Request.events(event_id).retrieve(params: params)
event = response.body

Значения для фильтра по значению до/после

filter = {
  filter: {
    value_after: [
      customers_statuses: [
        {
          status_id: 135751,
        },
        {
          status_id: 135754,
        }
      ]
    ]
  }
}

filter = {
  filter: {
    value_after: [
      value: '155',
    ],
    type: 'sale_field_changed',
    entity: 'lead'
  }
}

Типы событий

params = {
  language_code: 'en'
}

response = AmocrmRails::Request.events.types.retrieve(params: params)
events_types = response.body[:_embedded][:events_types]

Общая информация о примечаниях

Типы примечаний

Список примечаний по типу сущности

params = {
  page: 0,
  limit: 10
}

response = AmocrmRails::Request.leads.notes.retrieve(params: params)

response = AmocrmRails::Request.contacts.notes.retrieve(params: params)

response = AmocrmRails::Request.companies.notes.retrieve(params: params)

response = AmocrmRails::Request.customers.notes.retrieve(params: params)

notes = response.body[:_embedded][:notes]
note_id = notes.first[:id]

Список примечаний по конкретной сущности, по ID сущности

params = {
  page: 0,
  limit: 10
}

response = AmocrmRails::Request.leads(lead_id).notes.retrieve(params: params)

response = AmocrmRails::Request.contacts(contact_id).notes.retrieve(params: params)

response = AmocrmRails::Request.companies(company_id).notes.retrieve(params: params)

response = AmocrmRails::Request.customers(customer_id).notes.retrieve(params: params)

notes = response.body[:_embedded][:notes]
note_id = notes.first[:id]

Получение примечания по ID

response = AmocrmRails::Request.leads(lead_id).notes(note_id).retrieve

response = AmocrmRails::Request.contacts(contact_id).notes(note_id).retrieve

response = AmocrmRails::Request.companies(company_id).notes(note_id).retrieve

response = AmocrmRails::Request.customers(customer_id).notes(note_id).retrieve

note = response.body

Добавление примечаний

body = [
  {
    entity_id: 167353,
    note_type: "call_in",
    params: {
      uniq: "8f52d38a-5fb3-406d-93a3-a4832dc28f8b",
      duration: 60,
      source: "onlinePBX",
      link: "https://deppa.ru",
      phone: "+79999999999"
    }
  },
  {
    entity_id: 167353,
    note_type: "call_out",
    params: {
      uniq: "8f52d38a-5fb3-406d-93a3-a4832dc28f8b",
      duration: 60,
      source: "onlinePBX",
      link: "https://deppa.ru",
      phone: "+79999999999"
    }
  },
  {
    entity_id: 167353,
    note_type: "geolocation",
    params: {
      text: "Примечание с геолокацией",
      address: "ул. Пушкина, дом Колотушкина, квартира Вольнова",
      longitude: "53.714816",
      latitude: "91.423146"
    }
  }
]
body_item = {
  entity_id: 167353,
  note_type: "call_in",
  params: {
    uniq: "8f52d38a-5fb3-406d-93a3-a4832dc28f8b",
    duration: 60,
    source: "onlinePBX",
    link: "https://deppa.ru",
    phone: "+79999999999"
  }
}

AmocrmRails::Request.leads.notes.create(body: body)
AmocrmRails::Request.leads(lead_id).notes.create(body: body_item)

AmocrmRails::Request.contacts.notes.create(body: body)
AmocrmRails::Request.contacts(contact_id).notes.create(body: body_item)

AmocrmRails::Request.companies.notes.create(body: body)
AmocrmRails::Request.companies(company_id).notes.create(body: body_item)

AmocrmRails::Request.customers.notes.create(body: body)
AmocrmRails::Request.customers(customer_id).notes.create(body: body_item)

notes = response.body[:_embedded][:notes]
note_id = notes.first[:id]

Редактирование примечаний

body = [
  {
    entity_id: 167353,
    note_type: "call_in",
    params: {
      uniq: "8f52d38a-5fb3-406d-93a3-a4832dc28f8b",
      duration: 60,
      source: "onlinePBX",
      link: "https://deppa.ru",
      phone: "+79999999999"
    }
  },
  {
    entity_id: 167353,
    note_type: "call_out",
    params: {
      uniq: "8f52d38a-5fb3-406d-93a3-a4832dc28f8b",
      duration: 60,
      source: "onlinePBX",
      link: "https://deppa.ru",
      phone: "+79999999999"
    }
  },
  {
    entity_id: 167353,
    note_type: "geolocation",
    params: {
      text: "Примечание с геолокацией",
      address: "ул. Пушкина, дом Колотушкина, квартира Вольнова",
      longitude: "53.714816",
      latitude: "91.423146"
    }
  }
]
body_item = {
  entity_id: 167353,
  note_type: "call_in",
  params: {
    uniq: "8f52d38a-5fb3-406d-93a3-a4832dc28f8b",
    duration: 60,
    source: "onlinePBX",
    link: "https://deppa.ru",
    phone: "+79999999999"
  }
}

AmocrmRails::Request.leads.notes.update(body: body)
AmocrmRails::Request.leads(lead_id).notes.update(body: body_item)

AmocrmRails::Request.contacts.notes.update(body: body)
AmocrmRails::Request.contacts(contact_id).notes.update(body: body_item)

AmocrmRails::Request.companies.notes.update(body: body)
AmocrmRails::Request.companies(company_id).notes.update(body: body_item)

AmocrmRails::Request.customers.notes.update(body: body)
AmocrmRails::Request.customers(customer_id).notes.update(body: body_item)

notes = response.body[:_embedded][:notes]
note_id = notes.first[:id]

Покупатели

Включение покупателей и смена их режима

body = {
  mode: "segments",
  is_enabled: true
}
response = AmocrmRails::Request.customers.mode.update(body: body)
p(response.body)

Список покупателей

params = {
  with: 'contacts',
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.customers.retrieve(params: params)
customers = response.body[:_embedded][:customers]
customer_id = customers.first[:id]

Получение покупателя по ID

params = {
  with: 'contacts'
}
response = AmocrmRails::Request.customers(customer_id).retrieve(params: params)
customer = response.body

Добавление покупателей

body = [
    {
      name: "Покупатель для примера 1",
      created_by: 0
    },
    {
      name: "Покупатель для примера 2",
      _embedded: {
        tags: [
                {
                    "name": "Важный покупатель"
                }
            ]
        }
    }
]
response = AmocrmRails::Request.customers.create(body: body)
customers = response.body[:_embedded][:customers]
customer_id = customers.first[:id]

Редактирование покупателей

body = [
  {
    id: customer_id,
    name: "Новое название покупателя",
    _embedded: {
      tags: [
        {
          name: "Тег 125"
        }
      ]
    }
  }
]
response = AmocrmRails::Request.customers.update(body: body)
customers = response.body[:_embedded][:customers]
customer_id = customers.first[:id]

Редактирование покупателя

body = {
  name: "Новое название покупателя",
  _embedded: {
    tags: [
      {
        name: "Тег 125"
      }
    ]
  }
}
response = AmocrmRails::Request.customers(customer_id).update(body: body)
customer = response.body

Список транзакций

params = {
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.customers.transactions.retrieve(params: params)
response = AmocrmRails::Request.customers(customer_id).transactions.retrieve(params: params)

transactions = response.body[:_embedded][:transactions]
transaction_id = transactions.first[:id]

Получение транзакции по ID

response = AmocrmRails::Request.customers.transactions(transaction_id).retrieve
response = AmocrmRails::Request.customers(customer_id).transactions(transaction_id).retrieve

transaction = response.body

Добавление транзакций к покупателю

body = [
  {
    price: 123,
    created_by: 0,
    comment: "Комментарий",
    _embedded: {
      catalog_elements: [
        {
          id: 1677,
          metadata: {
            catalog_id: 1079,
            quantity: 10
          }
        }
      ]
    }
  }
]
response = AmocrmRails::Request.customers(customer_id).transactions.create(body: body)
p(response.body)
transactions = response.body[:_embedded][:transactions]
transaction_id = transactions.first[:id]

Удаление транзакции

response = AmocrmRails::Request.customers.transactions(transaction_id).delete
p(response.body)

Списание/начисление бонусных баллов покупателю

body = {
  earn: 500
}
response = AmocrmRails::Request.customers(customer_id).bonus_points.create(body: body)
p(response.body)

Статусы и сегменты покупателей

Список статусов покупателей

response = AmocrmRails::Request.customers.statuses.retrieve
statuses = response.body[:_embedded][:statuses]
status_id = statuses.first[:id]

Получение статуса покупателей по ID

response = AmocrmRails::Request.customers.statuses(status_id).retrieve
status = response.body

Добавление статусов в воронку

body = [
  {
    name: "Новый статус",
    sort: 100,
    color: "#fffeb2"
  },
  {
    name: "Новый статус 2",
    sort: 200,
    color: "#fffeb2"
  }
]
response = AmocrmRails::Request.customers.statuses.create(body: body)
p(response.body)
statuses = response.body[:_embedded][:statuses]
status_id = statuses.first[:id]

Редактирование статуса покупателей

body = {
  name: "Новое название для статуса",
  color: "#c1e0ff"
}
response = AmocrmRails::Request.customers.statuses(status_id).update(body: body)
customer = response.body

Удаление статуса покупателей

AmocrmRails::Request.customers.statuses(status_id).delete

Список сегментов покупателей

response = AmocrmRails::Request.customers.segments
segments = response.body[:_embedded][:segments]
segment_id = segments.first[:id]

Получение сегмента покупателей по ID

response = AmocrmRails::Request.customers.segments(segment_id).retrieve
segment = response.body

Добавление сегмента покупателей

body = {
  name: "Сегмент для примера",
  color: "ae003f"
}
response = AmocrmRails::Request.customers.segments.create(body: body)
p(response.body)
segment = response.body
segment_id = segment[:id]

Редактирование сегмента покупателей

body = {
  name: "Новое имя для сегмента",
  color: "ae003f"
}
response = AmocrmRails::Request.customers.segments(segment_id).update(body: body)
segment = response.body

Удаление сегмента покупателей

AmocrmRails::Request.customers.segments(segment_id).delete

Доступные цвета статусов

Доступные цвета сегментов

Пользователи

Список пользователей

params = {
  with: 'group',
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.users.retrieve
users = response.body[:_embedded][:users]
user_id = users.first[:id]

Получение пользователя по ID

params = {
  with: 'group'
}
response = AmocrmRails::Request.users(user_id).retrieve(params: params)
user = response.body
user_id = user[:id]

Добавление пользователей

body = [
  {
    name: "Павел Осетров",
    email: 'pavel.osetrov@me.com'
  }
]
response = AmocrmRails::Request.users.create(body: body)
p(response.body)
users = response.body[:_embedded][:users]
user_id = users.first[:id]

Список ролей пользователей

params = {
  with: 'users',
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.roles.retrieve
roles = response.body[:_embedded][:roles]
role_id = roles.first[:id]

Получение роли по ID

params = {
  with: 'users'
}
response = AmocrmRails::Request.roles(role_id).retrieve(params: params)
role = response.body
role_id = user[:id]

Добавление ролей

body = [
  {
    name: "role 3",
    rights: {
      leads: {
        add: "A",
        edit: "G",
        view: "G",
        delete: "G",
        export: "G"
      },
      tasks: {
        edit: "A",
        delete: "A"
      },
      contacts: {
        add: "A",
        edit: "A",
        view: "A",
        delete: "A",
        export: "A"
      },
      companies: {
        add: "A",
        edit: "A",
        view: "A",
        delete: "A",
        export: "A"
      },
      mail_access: true,
      status_rights: [
        {
          entity_type: "leads",
          pipeline_id: 16056,
          status_id: 20542166,
          rights: {
            edit: "A",
            view: "A",
            delete: "A",
            export: "A"
          }
        }
      ],
      catalog_access: true
    }
  }
]
response = AmocrmRails::Request.roles.create(body: body)
p(response.body)
roles = response.body[:_embedded][:roles]
role_id = roles.first[:id]

Редактирование роли

body = {
  name: "role 3 modified",
  rights: {
    contacts: {
      add: "A",
      edit: "D",
      view: "D",
      delete: "D",
      export: "D"
    },
    status_rights: nil
  }
}
response = AmocrmRails::Request.roles(role_id).update(body: body)
role = response.body

Удаление роли

AmocrmRails::Request.roles(role_id).delete

Общие обозначения прав пользователей

Зависимости прав пользователей

Товары

body = [
      {
        name: "Автомобильный держатель Mage Safe Qi для iPhone, магнитный",
        description: "",
        :custom_fields_values=>[
          {
            :field_id=>82661,
            :field_name=>"Артикул", 
            :field_code=>"SKU",
            :field_type=>"text",
            :values=>[{:value=>"55185"}]
          },
          {
            :field_id=>82661,
            :field_name=>"Группа",
            :field_code=>"GROUP",
            :field_type=>"category",
            :values=>[{:value=>"Автомобильные держатели", :enum_id=>category_id}]
          },
          {
            :field_id=>82665,
            :field_name=>"Цена",
            :field_code=>"PRICE",
            :field_type=>"price",
            :values=>[{:value=>3390}]
          }
        ]
      }
    ]
    response = AmocrmRails::Request.catalogs(catalog_id).elements.create(body: body)
    elements = response.body[:_embedded][:elements]
    element_id = elements.first[:id]

Вебхуки

Список установленных вебхуков в аккаунте

response = AmocrmRails::Request.webhooks.retrieve
webhooks = response.body[:_embedded][:webhooks]
webhook_id = webhooks.first[:id]

Подписка на вебхук

body = {
  destination: "https://deppa.ru",
  settings: [
    "add_lead"
  ],
  sort: 10
}
response = AmocrmRails::Request.webhooks.create(body: body)
p(response.body)
webhook = response.body
webhook_id = webhook[:id]

Отписка от событий

AmocrmRails::Request.webhooks(webhook_id).delete

Возможные событий

Виджеты

Список виджетов

params = {
  page: 0,
  limit: 10
}
response = AmocrmRails::Request.widgets.retrieve
widgets = response.body[:_embedded][:widgets]
widget_code = widgets.first[:code]

Информация о виджете по его коду

response = AmocrmRails::Request.widgets(widget_code).retrieve
widget = response.body

Установка виджета в аккаунт

body = {
  login: "example",
  password: "eXaMp1E",
  script_path: "https://deppa.ru/"
}
response = AmocrmRails::Request.widgets.create(body: body)
p(response.body)
widget = response.body

Удаление установки виджета

AmocrmRails::Request.widgets(widget_code).delete

Подтверждение выполнения блока виджета в Salesbot

body = {
  data: {
    status: "success"
  },
  execute_handlers: [
    {
      handler: "show",
      params: {
        type: "text",
        value: "Здесь текст"
      }
    },
    {
      handler: "show",
      params: {
        type: "buttons",
        value: "Нажми на кнопку",
        buttons: [
          "1ая кнопка",
          "2ая кнопка",
          "3ая кнопка",
          "4ая кнопка"
        ]
      }
    },
    {
      handler: "show",
      params: {
        type: "buttons_url",
        value: "Кнопки со ссылками",
        buttons: [
          "https://amocrm.ru",
          "https://deppa.ru"
        ]
      }
    },
    {
      handler: "goto",
      params: {
        type: "question|answer|finish",
        step: 5
      }
    }
  ]
}
AmocrmRails::Request.salesbot(bot_id).continue(continue_id).create(body: body)
AmocrmRails::Request.marketingbot(bot_id).continue(continue_id).create(body: body)

Добавление звонков

body = [
  {
    duration: 10,
    source: "example_integration",
    phone: "123123",
    link: "https://deppa.ru/audio.mp3",
    direction: "inbound",
    call_result: "Успешный разговор",
    call_status: 4
  }
]
response = AmocrmRails::Request.calls.create(body: body)
p(response.body)
calls = response.body[:_embedded][:calls]

Salebot

body = [
  {
    bot_id: 565,
    entity_id: 76687686,
    entity_type: 1
  }
]
response = AmocrmRails::Request.salesbot.run.create(body: body)
p(response.body)

Короткие ссылки

body = [
  {
    url:"https://deppa.ru",
    metadata:{
      entity_type:"contacts",
      entity_id:11070881
    }
  }
]
response = AmocrmRails::Request.short_links.create(body: body)
p(response.body)
short_links = response.body[:_embedded][:short_links]

FAQs

What is amocrm-rails?

Is amocrm-rails well maintained?

Package last updated on 08 Feb 2022

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

amocrm-rails

Amocrm для Rails

Оглавление

Установка

Получение CLIENT_ID, CLIENT_SECRET и CODE

Упрощенная авторизация

Авторизация через перенаправления пользователя (требуется gem Devise)

Сделки

Неразобранное

Воронки и этапы