zoho_hub 0.1.25 → 0.2.0

data/lib/zoho_hub/records/attachment.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require 'zoho_hub/records/base_record'
-
-module ZohoHub
-  class Attachment < BaseRecord
-    attributes :id, :parent_id, :file_name, :link_url, :type, :created_time
-    attributes :parent, :attachment_url
-
-    # The translation from attribute name to the JSON field on Zoho. The default behaviour will be
-    # to Camel_Case the attribute so on this list we should only have exceptions to this rule.
-    attribute_translation(
-      id: :id,
-      link_url: :'$link_url',
-      type: :'$type'
-    )
-
-    def initialize(params)
-      attributes.each do |attr|
-        zoho_key = attr_to_zoho_key(attr)
-
-        send("#{attr}=", params[zoho_key] || params[attr])
-      end
-
-      @parent_id = params.dig(:Parent_Id, :id)
-    end
-
-    class << self
-      def exists?(id, parent:)
-        !find(id, parent: parent).nil?
-      rescue RecordNotFound
-        false
-      end
-
-      def find(id, parent:)
-        body = get(File.join(request_path, id.to_s), parent: parent)
-        response = build_response(body)
-
-        if response.empty?
-          raise RecordNotFound, "Couldn't find #{request_path.singularize} with 'id'=#{id}"
-        end
-
-        new(response.data)
-      end
-
-      def get(path, parent:, **params)
-        # remove /search added by where method
-        path = path.sub('/search', '')
-        ZohoHub.connection.get(parent_module_path(path, parent), params)
-      end
-
-      def post(path, parent:, **params)
-        ZohoHub.connection.post(parent_module_path(path, parent), params) do |conn|
-          conn.request :multipart
-          conn.request :url_encoded
-        end
-      end
-
-      def put(_path, _params = {})
-        raise NotImplementedError
-      end
-
-      def parent_module_path(path, parent)
-        File.join(
-          parent.class.request_path,
-          parent.id,
-          path
-        )
-      end
-    end
-
-    def post(path, _params = {})
-      self.class.post(path, parent: parent, **to_params)
-    end
-
-    def put(_path, _params = {})
-      raise NotImplementedError
-    end
-
-    def save(*)
-      super
-    rescue => e
-      if e.message.include?('Attachment link already exists')
-        raise AttachmentLinkTakenError, e.message
-      else
-        raise e
-      end
-    end
-
-    def to_params
-      { attachmentUrl: attachment_url }
-    end
-
-    private
-
-    def to_input(**)
-      to_params
-    end
-
-    def parent_module_path(path)
-      self.class.parent_module_path(path, parent)
-    end
-  end
-end

data/lib/zoho_hub/records/base_record.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-require 'zoho_hub/response'
-
-module ZohoHub
-  class BaseRecord
-    class << self
-      def request_path(name = nil)
-        @request_path = name if name
-        @request_path ||= to_s.demodulize.pluralize
-        @request_path
-      end
-
-      def attributes(*attributes)
-        @attributes ||= []
-
-        return @attributes unless attributes
-
-        attr_accessor(*attributes)
-
-        @attributes += attributes
-      end
-
-      def attribute_translation(translation = nil)
-        @attribute_translation ||= {}
-
-        return @attribute_translation unless translation
-
-        @attribute_translation = translation
-      end
-
-      def zoho_key_translation
-        @attribute_translation.to_a.map(&:rotate).to_h
-      end
-
-      def find(id)
-        body = get(File.join(request_path, id.to_s))
-        response = build_response(body)
-
-        if response.empty?
-          raise RecordNotFound, "Couldn't find #{request_path.singularize} with 'id'=#{id}"
-        end
-
-        new(response.data)
-      end
-
-      def where(params)
-        path = File.join(request_path, 'search')
-
-        response = get(path, params)
-
-        data = response.nil? ? [] : response.fetch(:data, [])
-
-        data.map { |info| new(info) }
-      end
-
-      def find_by(params)
-        records = where(params)
-        records.first
-      end
-
-      def create(params)
-        new(params).save
-      end
-
-      def all(options = {})
-        options[:page] ||= 1
-        options[:per_page] ||= 200
-
-        body = get(request_path, options)
-        response = build_response(body)
-
-        data = response.nil? ? [] : response.data
-
-        data.map { |info| new(info) }
-      end
-
-      def get(path, params = {}, &block)
-        ZohoHub.connection.get(path, params, &block)
-      end
-
-      def post(path, params = {}, &block)
-        ZohoHub.connection.post(path, params.to_json, &block)
-      end
-
-      def put(path, params = {}, &block)
-        ZohoHub.connection.put(path, params.to_json, &block)
-      end
-
-      def exists?(id)
-        !find(id).nil?
-      rescue RecordNotFound
-        false
-      end
-
-      alias exist? exists?
-
-      def build_response(body)
-        response = Response.new(body)
-
-        raise InvalidTokenError, response.msg if response.invalid_token?
-        raise RecordInvalid, response.msg if response.invalid_data?
-
-        response
-      end
-    end
-
-    def attributes
-      self.class.attributes
-    end
-
-    def get(path, params = {})
-      self.class.get(path, params)
-    end
-
-    def post(path, params = {})
-      self.class.post(path, params)
-    end
-
-    def put(path, params = {})
-      self.class.put(path, params)
-    end
-
-    # Save the record to Zoho
-    # trigger: ['workflow', 'approval', 'blueprint']
-    def save(trigger:)
-      body = if new_record? # create new record
-               post(self.class.request_path, to_input(trigger: trigger))
-             else # update existing record
-               path = File.join(self.class.request_path, id)
-               put(path, to_input(trigger: trigger))
-             end
-
-      response = build_response(body)
-
-      id = response.data.dig(:details, :id)
-
-      return id if id
-
-      # Invalid errors
-      response.data
-    end
-
-    def to_input(trigger:)
-      json = { data: [to_params] }
-      json[:trigger] = Array(trigger) if trigger
-
-      json
-    end
-
-    def new_record?
-      !id.present?
-    end
-
-    def to_params
-      params = {}
-
-      attributes.each do |attr|
-        key = attr_to_zoho_key(attr)
-
-        params[key] = send(attr)
-      end
-
-      params
-    end
-
-    def build_response(body)
-      self.class.build_response(body)
-    end
-
-    private
-
-    def attr_to_zoho_key(attr_name)
-      translations = self.class.attribute_translation
-
-      return translations[attr_name.to_sym] if translations.key?(attr_name.to_sym)
-
-      attr_name.to_s.split('_').map(&:capitalize).join('_').to_sym
-    end
-
-    def zoho_key_to_attr(zoho_key)
-      translations = self.class.zoho_key_translation
-
-      return translations[zoho_key.to_sym] if translations.key?(zoho_key.to_sym)
-
-      zoho_key.to_sym
-    end
-  end
-end

data/lib/zoho_hub/records/product.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module ZohoHub
-  class Product < BaseRecord
-    attributes :id, :description, :vendor_id, :owner_id, :active, :name
-
-    attribute_translation(
-      id: :id,
-      active: :Product_Active,
-      name: :Product_Name
-    )
-
-    def initialize(params)
-      puts Rainbow(params).magenta
-
-      attributes.each do |attr|
-        zoho_key = attr_to_zoho_key(attr)
-
-        send("#{attr}=", params[zoho_key] || params[attr])
-      end
-
-      @owner_id ||= params.dig(:Owner, :id)
-      @vendor_id ||= params.dig(:Vendor_Name, :id)
-    end
-
-    def to_params
-      params = super
-
-      params[:Owner] = { id: @owner_id } if @owner_id
-      params[:Vendor_Name] = { id: @vendor_id } if @vendor_id
-
-      params
-    end
-  end
-end

data/lib/zoho_hub/records/quote.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'zoho_hub/records/base_record'
-
-module ZohoHub
-  class Quote < BaseRecord
-    attributes :id, :stage, :subject, :potential_id, :owner_id, :product_id, :account_id, :extra_info
-
-    attribute_translation(
-      id: :id,
-      stage: :Quote_Stage
-    )
-
-    def initialize(params)
-      attributes.each do |attr|
-        zoho_key = attr_to_zoho_key(attr)
-        send("#{attr}=", params[zoho_key] || params[attr])
-      end
-
-      @potential_id ||= params.dig(:Deal_Name, :id)
-      @account_id ||= params.dig(:Account_Name, :id)
-      @owner_id ||= params.dig(:Owner, :id)
-
-      # The Quote has an array of products but we only care about one
-      if params.dig(:Product_Details)
-        product = params.dig(:Product_Details).first
-        @product_id = product.dig(:id)
-      end
-    end
-
-    def to_params
-      params = super
-
-      params[:Deal_Name] = { id: @potential_id } if @potential_id
-      params[:Account_Name] = { id: @account_id } if @account_id
-      params[:Owner] = { id: @owner_id } if @owner_id
-      params[:Product_Details] = [{ product: { id: @product_id }, quantity: 1 }] if @product_id
-
-      params
-    end
-  end
-end

data/lib/zoho_hub/records/vendor.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ZohoHub
-  class Vendor < BaseRecord
-    attributes :id, :email, :description, :vendor_name, :website, :owner_id, :phone, :currency
-    attributes :company_reg_no
-
-    attribute_translation(
-      id: :id
-    )
-
-    DEFAULTS = {
-      currency: 'GBP'
-    }.freeze
-
-    def initialize(params)
-      attributes.each do |attr|
-        zoho_key = attr_to_zoho_key(attr)
-
-        send("#{attr}=", params[zoho_key] || params[attr] || DEFAULTS[attr])
-      end
-
-      @owner_id ||= params.dig(:Owner, :id)
-    end
-
-    def to_params
-      params = super
-
-      params[:Owner] = { id: @owner_id } if @owner_id
-
-      params
-    end
-  end
-end