maestrano-connector-rails 1.2.1 → 1.2.2

data/app/controllers/maestrano/sessions_controller.rb

@@ -12,4 +12,4 @@ module Maestrano
       redirect_to root_url
     end
   end
-end
+end

data/app/controllers/maestrano/synchronizations_controller.rb

@@ -2,7 +2,7 @@ class Maestrano::SynchronizationsController < Maestrano::Rails::WebHookControlle
   def show
     uid = params[:id]
     organization = Maestrano::Connector::Rails::Organization.find_by_uid(uid)
-    return render json: { errors: {message: "Organization not found", code: 404} }, status: :not_found unless organization
+    return render json: {errors: {message: "Organization not found", code: 404}}, status: :not_found unless organization
 
     h = {
       group_id: organization.uid,
@@ -12,11 +12,9 @@ class Maestrano::SynchronizationsController < Maestrano::Rails::WebHookControlle
     last_sync = organization.synchronizations.last
     if last_sync
       h.merge!(
-        {
-          status: last_sync.status,
-          message: last_sync.message,
-          updated_at: last_sync.updated_at
-        }
+        status: last_sync.status,
+        message: last_sync.message,
+        updated_at: last_sync.updated_at
       )
     end
 
@@ -27,7 +25,7 @@ class Maestrano::SynchronizationsController < Maestrano::Rails::WebHookControlle
     uid = params[:group_id]
     opts = params[:opts] || {}
     organization = Maestrano::Connector::Rails::Organization.find_by_uid(uid)
-    return render json: { errors: {message: "Organization not found", code: 404} }, status: :not_found unless organization
+    return render json: {errors: {message: "Organization not found", code: 404}}, status: :not_found unless organization
 
     Maestrano::Connector::Rails::SynchronizationJob.perform_later(organization, opts.with_indifferent_access)
     head :created
@@ -36,11 +34,11 @@ class Maestrano::SynchronizationsController < Maestrano::Rails::WebHookControlle
   def toggle_sync
     uid = params[:group_id]
     organization = Maestrano::Connector::Rails::Organization.find_by_uid(uid)
-    return render json: { errors: {message: "Organization not found", code: 404} }, status: :not_found unless organization
+    return render json: {errors: {message: "Organization not found", code: 404}}, status: :not_found unless organization
 
     organization.toggle(:sync_enabled)
     organization.save
 
     render json: {sync_enabled: organization.sync_enabled}
   end
-end
+end

data/app/controllers/version_controller.rb

@@ -0,0 +1,9 @@
+class VersionController < ApplicationController
+  def index
+    framework_version = Gem.loaded_specs['maestrano-connector-rails'].version.version
+    respond_to do |format|
+      format.html { render text: "framework_version=#{framework_version}\n" }
+      format.json { render json: {framework_version: framework_version} }
+    end
+  end
+end

data/app/helpers/maestrano/connector/rails/session_helper.rb

@@ -1,6 +1,5 @@
 module Maestrano::Connector::Rails
   module SessionHelper
-
     def is_admin?(user, organization)
       organization.member?(user) && session[:"role_#{organization.uid}"] && ['Admin', 'Super Admin'].include?(session[:"role_#{organization.uid}"])
     end
@@ -16,6 +15,5 @@ module Maestrano::Connector::Rails
     def is_admin
       @is_admin ||= current_user && current_organization && is_admin?(current_user, current_organization)
     end
-
   end
 end

data/app/jobs/maestrano/connector/rails/all_synchronizations_job.rb

@@ -3,11 +3,11 @@ module Maestrano::Connector::Rails
     queue_as :default
 
     # Trigger synchronization of all active organizations
-    def perform(name=nil, count=nil)
+    def perform(name = nil, count = nil)
       Maestrano::Connector::Rails::Organization.where.not(oauth_provider: nil, encrypted_oauth_token: nil).each do |o|
         next unless [true, 1].include?(o.sync_enabled)
         Maestrano::Connector::Rails::SynchronizationJob.perform_later(o, {})
       end
     end
   end
-end
+end

data/app/jobs/maestrano/connector/rails/push_to_connec_job.rb

@@ -3,7 +3,7 @@ module Maestrano::Connector::Rails
     queue_as :default
 
     # expected hash: {"external_entity_name1" => [entity1, entity2], "external_entity_name2" => []}
-    def perform(organization, entities_hash, opts={})
+    def perform(organization, entities_hash, opts = {})
       return unless organization.sync_enabled && organization.oauth_uid
 
       connec_client = Maestrano::Connector::Rails::ConnecHelper.get_client(organization)
@@ -18,11 +18,11 @@ module Maestrano::Connector::Rails
 
           entity_instance.before_sync(last_synchronization_date)
           # Build expected input for consolidate_and_map_data
-          if entity_instance_hash[:is_complex]
-            mapped_entities = entity_instance.consolidate_and_map_data(ComplexEntity.build_empty_hash(entity_instance.class.connec_entities_names), ComplexEntity.build_hash_with_entities(entity_instance.class.external_entities_names, external_entity_name, lambda{|name| name}, entities))
-          else
-            mapped_entities = entity_instance.consolidate_and_map_data([], entities)
-          end
+          mapped_entities = if entity_instance_hash[:is_complex]
+                              entity_instance.consolidate_and_map_data(ComplexEntity.build_empty_hash(entity_instance.class.connec_entities_names), ComplexEntity.build_hash_with_entities(entity_instance.class.external_entities_names, external_entity_name, ->(name) { name }, entities))
+                            else
+                              entity_instance.consolidate_and_map_data([], entities)
+                            end
           entity_instance.push_entities_to_connec(mapped_entities[:external_entities])
 
           entity_instance.after_sync(last_synchronization_date)
@@ -33,6 +33,7 @@ module Maestrano::Connector::Rails
     end
 
     private
+
       def find_entity_instance(entity_name, organization, connec_client, external_client, opts)
         Maestrano::Connector::Rails::External.entities_list.each do |entity_name_from_list|
           clazz = "Entities::#{entity_name_from_list.singularize.titleize.split.join}".constantize
@@ -45,4 +46,4 @@ module Maestrano::Connector::Rails
         nil
       end
   end
-end
+end

data/app/jobs/maestrano/connector/rails/push_to_connec_worker.rb

@@ -7,13 +7,15 @@ module Maestrano::Connector::Rails
     sidekiq_options unique: :while_executing, unique_args: :unique_args
 
     def self.unique_args(args)
-      organization = args[0]
+      organization_id = args[0]
       entities_hash = args[1]
-      return[organization.id, entities_hash.keys.sort]
+
+      [organization_id, entities_hash.keys.sort]
     end
 
-    def perform(organization, entities_hash, opts={})
+    def perform(organization_id, entities_hash, opts = {})
+      organization = Organization.find(organization_id)
       PushToConnecJob.new.perform(organization, entities_hash, opts)
     end
   end
-end
+end

data/app/jobs/maestrano/connector/rails/synchronization_job.rb

@@ -7,19 +7,19 @@ module Maestrano::Connector::Rails
     #  * :only_entities => [person, tasks_list]
     #  * :full_sync => true  synchronization is performed without date filtering
     #  * :connec_preemption => true|false : preemption is always|never given to connec in case of conflict (if not set, the most recently updated entity is kept)
-    def perform(organization, opts={})
+    def perform(organization, opts = {})
       return unless organization.sync_enabled
 
       # Check if previous synchronization is still running
       if Synchronization.where(organization_id: organization.id, status: 'RUNNING').where(created_at: (30.minutes.ago..Time.now)).exists?
-        ConnectorLogger.log('info', organization, "Synchronization skipped: Previous synchronization is still running")
+        ConnectorLogger.log('info', organization, 'Synchronization skipped: Previous synchronization is still running')
         return
       end
 
       # Check if recovery mode: last 3 synchronizations have failed
       if !opts[:forced] && organization.last_three_synchronizations_failed? \
           && organization.synchronizations.order(created_at: :desc).limit(1).first.updated_at > 1.day.ago
-        ConnectorLogger.log('info', organization, "Synchronization skipped: Recovery mode (three previous synchronizations have failed)")
+        ConnectorLogger.log('info', organization, 'Synchronization skipped: Recovery mode (three previous synchronizations have failed)')
         return
       end
 
@@ -37,8 +37,8 @@ module Maestrano::Connector::Rails
         # We do a doube sync: only from external, then only from connec!
         # We also do batched sync as the first one can be quite huge
         if last_synchronization.nil?
-          ConnectorLogger.log('info', organization, "First synchronization ever. Doing two half syncs to allow smart merging to work its magic.")
-          organization.synchronized_entities.select{|k, v| v}.keys.each do |entity|
+          ConnectorLogger.log('info', organization, 'First synchronization ever. Doing two half syncs to allow smart merging to work its magic.')
+          organization.synchronized_entities.select { |k, v| v }.keys.each do |entity|
             ConnectorLogger.log('info', organization, "First synchronization ever. Doing half sync from external for #{entity}.")
             first_sync_entity(entity.to_s, organization, connec_client, external_client, last_synchronization_date, opts, true)
             ConnectorLogger.log('info', organization, "First synchronization ever. Doing half sync from Connec! for #{entity}.")
@@ -52,7 +52,7 @@ module Maestrano::Connector::Rails
             sync_entity(entity, organization, connec_client, external_client, last_synchronization_date, opts)
           end
         else
-          organization.synchronized_entities.select{|k, v| v}.keys.each do |entity|
+          organization.synchronized_entities.select { |_k, v| v }.keys.each do |entity|
             sync_entity(entity.to_s, organization, connec_client, external_client, last_synchronization_date, opts)
           end
         end
@@ -78,7 +78,7 @@ module Maestrano::Connector::Rails
       entities_count = limit
 
       h = {__limit: limit}
-      external ? h.merge!(__skip_connec: true) : h.merge!(__skip_external: true)
+      external ? h[:__skip_connec] = true : h[:__skip_external] = true
       entity_instance = instanciate_entity(entity_name, organization, connec_client, external_client, opts.merge(h))
 
       # IF entities_count > limit
@@ -87,7 +87,7 @@ module Maestrano::Connector::Rails
       # No need to fetch it a second Time
       # ELSIF entities_count < limit
       # No more entities to fetch
-      while entities_count == limit do
+      while entities_count == limit
         entity_instance.opts_merge!(__skip: skip)
         entities_count = perform_sync(entity_instance, last_synchronization_date, external)
         skip += limit
@@ -95,6 +95,7 @@ module Maestrano::Connector::Rails
     end
 
     private
+
       def instanciate_entity(entity_name, organization, connec_client, external_client, opts)
         "Entities::#{entity_name.titleize.split.join}".constantize.new(organization, connec_client, external_client, opts.dup)
       end
@@ -112,4 +113,4 @@ module Maestrano::Connector::Rails
         external ? entity_instance.class.count_entities(external_entities) : entity_instance.class.count_entities(connec_entities)
       end
   end
-end
+end

data/app/models/maestrano/connector/rails/complex_entity.rb

@@ -2,4 +2,4 @@ module Maestrano::Connector::Rails
   class ComplexEntity < EntityBase
     include Maestrano::Connector::Rails::Concerns::ComplexEntity
   end
-end
+end

data/app/models/maestrano/connector/rails/concerns/complex_entity.rb

@@ -7,11 +7,11 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
   # -------------------------------------------------------------
   module ClassMethods
     def connec_entities_names
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     def external_entities_names
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     def count_entities(entities)
@@ -33,7 +33,7 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
   #             }
   #          }
   def connec_model_to_external_model(connec_hash_of_entities)
-    raise "Not implemented"
+    raise 'Not implemented'
   end
 
   # input :  {
@@ -50,13 +50,13 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
   #             }
   #           }
   def external_model_to_connec_model(external_hash_of_entities)
-    raise "Not implemented"
+    raise 'Not implemented'
   end
 
   # -------------------------------------------------------------
   #          Entity equivalent methods
   # -------------------------------------------------------------
-  def get_connec_entities(last_synchronization_date=nil)
+  def get_connec_entities(last_synchronization_date = nil)
     entities = ActiveSupport::HashWithIndifferentAccess.new
 
     self.class.connec_entities_names.each do |connec_entity_name|
@@ -66,7 +66,7 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
     entities
   end
 
-  def get_external_entities_wrapper(last_synchronization_date=nil)
+  def get_external_entities_wrapper(last_synchronization_date = nil)
     entities = ActiveSupport::HashWithIndifferentAccess.new
 
     self.class.external_entities_names.each do |external_entity_name|
@@ -83,13 +83,12 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
     mapped_connec_entities = consolidate_and_map_connec_entities(modeled_connec_entities, modeled_external_entities)
     mapped_external_entities = consolidate_and_map_external_entities(modeled_external_entities)
 
-    return {connec_entities: mapped_connec_entities, external_entities: mapped_external_entities}
+    {connec_entities: mapped_connec_entities, external_entities: mapped_external_entities}
   end
 
   def consolidate_and_map_connec_entities(modeled_connec_entities, modeled_external_entities)
     modeled_connec_entities.each do |connec_entity_name, entities_in_external_model|
       entities_in_external_model.each do |external_entity_name, entities|
-
         sub_entity_instance = instantiate_sub_entity_instance(connec_entity_name)
         equivalent_external_entities = (modeled_external_entities[external_entity_name] && modeled_external_entities[external_entity_name][connec_entity_name]) || []
 
@@ -128,7 +127,6 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
     end
   end
 
-
   def push_entities_to_external(mapped_connec_entities_with_idmaps)
     mapped_connec_entities_with_idmaps.each do |connec_entity_name, entities_in_external_model|
       sub_entity_instance = instantiate_sub_entity_instance(connec_entity_name)
@@ -148,13 +146,13 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
   module ClassMethods
     # output : {entities_names[0] => [], entities_names[1] => []}
     def build_empty_hash(entities_names)
-      Hash[ *entities_names.collect{|name| [ name, []]}.flatten(1) ]
+      Hash[*entities_names.collect { |name| [name, []] }.flatten(1)]
     end
 
     # output: {entities_name[0] => [], entities_name[1] => entities}
     # with proc.call(entities_name[1] == entity_name)
     def build_hash_with_entities(entities_name, entity_name, proc, entities)
-      Hash[ *entities_name.collect{|name| proc.call(name) == entity_name ? [name, entities] : [ name, []]}.flatten(1) ]
+      Hash[*entities_name.collect { |name| proc.call(name) == entity_name ? [name, entities] : [name, []] }.flatten(1)]
     end
   end
-end
+end

data/app/models/maestrano/connector/rails/concerns/connec_helper.rb

@@ -25,7 +25,7 @@ module Maestrano::Connector::Rails::Concerns::ConnecHelper
       end
       @@connec_version
     end
-    
+
     # Replace the ids arrays by the external id
     # If a reference has no id for this oauth_provider and oauth_uid but has one for connec returns nil
     def unfold_references(connec_entity, references, organization)
@@ -33,13 +33,9 @@ module Maestrano::Connector::Rails::Concerns::ConnecHelper
       not_nil = true
 
       # Id
-      id = unfolded_connec_entity['id'].find{|id| id['provider'] == organization.oauth_provider && id['realm'] == organization.oauth_uid}
-      unfolded_connec_entity[:__connec_id] = unfolded_connec_entity['id'].find{|id| id['provider'] == 'connec'}['id']
-      if id
-        unfolded_connec_entity['id'] = id['id']
-      else
-        unfolded_connec_entity['id'] = nil
-      end
+      id_hash = unfolded_connec_entity['id'].find { |id| id['provider'] == organization.oauth_provider && id['realm'] == organization.oauth_uid }
+      unfolded_connec_entity[:__connec_id] = unfolded_connec_entity['id'].find { |id| id['provider'] == 'connec' }['id']
+      unfolded_connec_entity['id'] = id_hash ? id_hash['id'] : nil
 
       # Other refs
       references.each do |reference|
@@ -67,20 +63,19 @@ module Maestrano::Connector::Rails::Concerns::ConnecHelper
     def fold_references_helper(entity, array_of_refs, organization)
       ref = array_of_refs.shift
       field = entity[ref]
+      return if field.blank?
 
       # Follow embedment path, remplace if it's not an array or a hash
-      unless field.blank?
-        case field
-        when Array
-          field.each do |f|
-            fold_references_helper(f, array_of_refs.dup, organization)
-          end
-        when HashWithIndifferentAccess
-          fold_references_helper(entity[ref], array_of_refs, organization)
-        else
-          id = field
-          entity[ref] = [id_hash(id, organization)]
+      case field
+      when Array
+        field.each do |f|
+          fold_references_helper(f, array_of_refs.dup, organization)
         end
+      when HashWithIndifferentAccess
+        fold_references_helper(entity[ref], array_of_refs, organization)
+      else
+        id = field
+        entity[ref] = [id_hash(id, organization)]
       end
     end
 
@@ -89,10 +84,11 @@ module Maestrano::Connector::Rails::Concerns::ConnecHelper
       field = entity[ref]
 
       # Unfold the id
-      if array_of_refs.empty?
-        if id = field && field.find{|id| id[:provider] == organization.oauth_provider && id[:realm] == organization.oauth_uid}
-          entity[ref] = id['id']
-        elsif field && field.find{|id| id[:provider] == 'connec'}
+      if array_of_refs.empty? && field
+        id_hash = field.find { |id| id[:provider] == organization.oauth_provider && id[:realm] == organization.oauth_uid }
+        if id_hash
+          entity[ref] = id_hash['id']
+        elsif field.find { |id| id[:provider] == 'connec' } # Should always be true as ids will always contain a connec id
           # We may enqueue a fetch on the endpoint of the missing association, followed by a re-fetch on this one.
           # However it's expected to be an edge case, so for now we rely on the fact that the webhooks should be relativly in order.
           # Worst case it'll be done on following sync
@@ -114,6 +110,5 @@ module Maestrano::Connector::Rails::Concerns::ConnecHelper
       end
       true
     end
-
   end
-end
+end

data/app/models/maestrano/connector/rails/concerns/connector_logger.rb

@@ -6,4 +6,4 @@ module Maestrano::Connector::Rails::Concerns::ConnectorLogger
       Rails.logger.method(level).call("org: #{organization.uid} (#{organization.tenant}). Msg: #{msg}")
     end
   end
-end
+end

data/app/models/maestrano/connector/rails/concerns/entity.rb

@@ -19,9 +19,11 @@ module Maestrano::Connector::Rails::Concerns::Entity
     def find_or_create_idmap(organization_and_id)
       Maestrano::Connector::Rails::IdMap.find_or_create_by(names_hash.merge(organization_and_id))
     end
+
     def find_idmap(organization_and_id)
       Maestrano::Connector::Rails::IdMap.find_by(names_hash.merge(organization_and_id))
     end
+
     def create_idmap(organization_and_id)
       Maestrano::Connector::Rails::IdMap.create(names_hash.merge(organization_and_id))
     end
@@ -45,25 +47,25 @@ module Maestrano::Connector::Rails::Concerns::Entity
     #             External methods
     # ----------------------------------------------
     def id_from_external_entity_hash(entity)
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     def last_update_date_from_external_entity_hash(entity)
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     def creation_date_from_external_entity_hash(entity)
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     # Return a string representing the object from a connec! entity hash
     def object_name_from_connec_entity_hash(entity)
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     # Return a string representing the object from an external entity hash
     def object_name_from_external_entity_hash(entity)
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     # Returns a boolean
@@ -71,6 +73,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
     def inactive_from_external_entity_hash?(entity)
       false
     end
+
     # ----------------------------------------------
     #             Entity specific methods
     # Those methods need to be define in each entity
@@ -82,17 +85,17 @@ module Maestrano::Connector::Rails::Concerns::Entity
 
     # Entity name in Connec!
     def connec_entity_name
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     # Entity name in external system
     def external_entity_name
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     # Entity Mapper Class
     def mapper_class
-      raise "Not implemented"
+      raise 'Not implemented'
     end
 
     # An array of connec fields that are references
@@ -153,7 +156,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
   def map_to_connec(entity)
     mapped_entity = self.class.mapper_class.denormalize(entity).merge(id: self.class.id_from_external_entity_hash(entity))
     folded_entity = Maestrano::Connector::Rails::ConnecHelper.fold_references(mapped_entity, self.class.references, @organization)
-    folded_entity.merge!(opts: (mapped_entity[:opts] || {}).merge(matching_fields: self.class.connec_matching_fields)) if self.class.connec_matching_fields
+    folded_entity[:opts] = (mapped_entity[:opts] || {}).merge(matching_fields: self.class.connec_matching_fields) if self.class.connec_matching_fields
     folded_entity
   end
 
@@ -164,12 +167,11 @@ module Maestrano::Connector::Rails::Concerns::Entity
   # * full_sync
   # * $filter (see Connec! documentation)
   # * $orderby (see Connec! documentation)
-  def get_connec_entities(last_synchronization_date=nil)
+  def get_connec_entities(last_synchronization_date = nil)
     return [] if @opts[:__skip_connec] || !self.class.can_read_connec?
 
     Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Fetching Connec! #{self.class.connec_entity_name}")
 
-    entities = []
     query_params = {}
     query_params[:$orderby] = @opts[:$orderby] if @opts[:$orderby]
 
@@ -191,7 +193,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
     Maestrano::Connector::Rails::ConnectorLogger.log('debug', @organization, "entity=#{self.class.connec_entity_name}, fetching data with #{query_params.to_query}")
     uri = "#{self.class.normalized_connec_entity_name}?#{query_params.to_query}"
     response_hash = fetch_connec(uri, 0)
-    entities = response_hash["#{self.class.normalized_connec_entity_name}"]
+    entities = response_hash[self.class.normalized_connec_entity_name]
     entities = [entities] if self.class.singleton?
 
     # Only the first page if batched_fetch
@@ -203,7 +205,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
         next_page = response_hash['pagination']['next'].gsub(/^(.*)\/#{self.class.normalized_connec_entity_name}/, self.class.normalized_connec_entity_name)
 
         response_hash = fetch_connec(next_page, page_number)
-        entities << response_hash["#{self.class.normalized_connec_entity_name}"]
+        entities << response_hash[self.class.normalized_connec_entity_name]
       end
     end
 
@@ -220,8 +222,8 @@ module Maestrano::Connector::Rails::Concerns::Entity
     return unless self.class.can_write_connec?
 
     Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Sending #{Maestrano::Connector::Rails::External.external_name} #{self.class.external_entity_name.pluralize} to Connec! #{connec_entity_name.pluralize}")
-    
-    proc = lambda{|mapped_external_entity_with_idmap| batch_op('post', mapped_external_entity_with_idmap[:entity], nil, self.class.normalize_connec_entity_name(connec_entity_name))}
+
+    proc = ->(mapped_external_entity_with_idmap) { batch_op('post', mapped_external_entity_with_idmap[:entity], nil, self.class.normalize_connec_entity_name(connec_entity_name)) }
     batch_calls(mapped_external_entities_with_idmaps, proc, connec_entity_name)
   end
 
@@ -231,7 +233,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
       method: method,
       url: "/api/v2/#{@organization.uid}/#{connec_entity_name}/#{id}", # id should be nil for POST
       params: {
-        "#{connec_entity_name}".to_sym => mapped_external_entity
+        connec_entity_name.to_sym => mapped_external_entity
       }
     }
   end
@@ -239,14 +241,14 @@ module Maestrano::Connector::Rails::Concerns::Entity
   # ----------------------------------------------
   #                 External methods
   # ----------------------------------------------
-  def get_external_entities_wrapper(last_synchronization_date=nil)
+  def get_external_entities_wrapper(last_synchronization_date = nil)
     return [] if @opts[:__skip_external] || !self.class.can_read_external?
     get_external_entities(last_synchronization_date)
   end
-  
-  def get_external_entities(last_synchronization_date=nil)
+
+  def get_external_entities(last_synchronization_date = nil)
     Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Fetching #{Maestrano::Connector::Rails::External.external_name} #{self.class.external_entity_name.pluralize}")
-    raise "Not implemented"
+    raise 'Not implemented'
   end
 
   def push_entities_to_external(mapped_connec_entities_with_idmaps)
@@ -262,13 +264,12 @@ module Maestrano::Connector::Rails::Concerns::Entity
       idmap ? {idmap: idmap} : nil
     }.compact
 
-    unless ids_to_send_to_connec.empty?
-      # Send the external ids to connec if it was a creation
-      proc = lambda{|id| batch_op('put', {id: [Maestrano::Connector::Rails::ConnecHelper.id_hash(id[:idmap].external_id, @organization)]}, id[:idmap].connec_id, self.class.normalize_connec_entity_name(self.class.connec_entity_name)) }
-      batch_calls(ids_to_send_to_connec, proc, self.class.connec_entity_name, true)
-    end
-  end
+    return if ids_to_send_to_connec.empty?
 
+    # Send the external ids to connec if it was a creation
+    proc = ->(id) { batch_op('put', {id: [Maestrano::Connector::Rails::ConnecHelper.id_hash(id[:idmap].external_id, @organization)]}, id[:idmap].connec_id, self.class.normalize_connec_entity_name(self.class.connec_entity_name)) }
+    batch_calls(ids_to_send_to_connec, proc, self.class.connec_entity_name, true)
+  end
 
   def push_entity_to_external(mapped_connec_entity_with_idmap, external_entity_name)
     idmap = mapped_connec_entity_with_idmap[:idmap]
@@ -277,7 +278,6 @@ module Maestrano::Connector::Rails::Concerns::Entity
     begin
       # Create and return id to send to connec!
       if idmap.external_id.blank?
-        connec_id = idmap.connec_id
         external_id = create_external_entity(mapped_connec_entity, external_entity_name)
         idmap.update(external_id: external_id, last_push_to_external: Time.now, message: nil)
         return idmap
@@ -289,13 +289,12 @@ module Maestrano::Connector::Rails::Concerns::Entity
 
         # Return the id to send it to connec! if the first push of a singleton
         if self.class.singleton? && idmap.last_push_to_external.nil?
-          connec_id = mapped_connec_entity_with_idmap[:idmap].connec_id
           idmap.update(last_push_to_external: Time.now, message: nil)
           return idmap
         else
           idmap.update(last_push_to_external: Time.now, message: nil)
         end
-        
+
       end
     rescue => e
       # Store External error
@@ -307,12 +306,12 @@ module Maestrano::Connector::Rails::Concerns::Entity
 
   def create_external_entity(mapped_connec_entity, external_entity_name)
     Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Sending create #{external_entity_name}: #{mapped_connec_entity} to #{Maestrano::Connector::Rails::External.external_name}")
-    raise "Not implemented"
+    raise 'Not implemented'
   end
 
   def update_external_entity(mapped_connec_entity, external_id, external_entity_name)
     Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Sending update #{external_entity_name} (id=#{external_id}): #{mapped_connec_entity} to #{Maestrano::Connector::Rails::External.external_name}")
-    raise "Not implemented"
+    raise 'Not implemented'
   end
 
   # ----------------------------------------------
@@ -329,7 +328,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
     mapped_connec_entities = consolidate_and_map_connec_entities(connec_entities, external_entities, self.class.references, self.class.external_entity_name)
     mapped_external_entities = consolidate_and_map_external_entities(external_entities, self.class.connec_entity_name)
 
-    return {connec_entities: mapped_connec_entities, external_entities: mapped_external_entities}
+    {connec_entities: mapped_connec_entities, external_entities: mapped_external_entities}
   end
 
   def consolidate_and_map_connec_entities(connec_entities, external_entities, references, external_entity_name)
@@ -374,7 +373,6 @@ module Maestrano::Connector::Rails::Concerns::Entity
       # Entity has not been modified since its last push to connec!
       next nil if !@opts[:full_sync] && not_modified_since_last_push_to_connec?(idmap, entity)
 
-
       map_external_entity_with_idmap(entity, connec_entity_name, idmap)
     }.compact
   end
@@ -382,18 +380,18 @@ module Maestrano::Connector::Rails::Concerns::Entity
   def consolidate_and_map_singleton(connec_entities, external_entities)
     return {connec_entities: [], external_entities: []} if external_entities.empty? && connec_entities.empty?
 
-    idmap = self.class.find_or_create_idmap({organization_id: @organization.id})
+    idmap = self.class.find_or_create_idmap(organization_id: @organization.id)
     # No to_connec, to_external and inactive consideration here as we don't expect those workflow for singleton
 
-    if external_entities.empty?
-      keep_external = false
-    elsif connec_entities.empty?
-      keep_external = true
-    elsif @opts.has_key?(:connec_preemption)
-      keep_external = !@opts[:connec_preemption]
-    else
-      keep_external = !is_connec_more_recent?(connec_entities.first, external_entities.first)
-    end
+    keep_external = if external_entities.empty?
+                      false
+                    elsif connec_entities.empty?
+                      true
+                    elsif @opts.key?(:connec_preemption)
+                      !@opts[:connec_preemption]
+                    else
+                      !is_connec_more_recent?(connec_entities.first, external_entities.first)
+                    end
 
     if keep_external
       idmap.update(external_id: self.class.id_from_external_entity_hash(external_entities.first), name: self.class.object_name_from_external_entity_hash(external_entities.first))
@@ -410,9 +408,10 @@ module Maestrano::Connector::Rails::Concerns::Entity
   #             Internal helper methods
   # ----------------------------------------------
   private
+
     # array_with_idmap must be an array of hashes with a key idmap
     # proc is a lambda to create a batch_op from an element of the array
-    def batch_calls(array_with_idmap, proc, connec_entity_name, id_update_only=false)
+    def batch_calls(array_with_idmap, proc, connec_entity_name, id_update_only = false)
       request_per_call = @opts[:request_per_batch_call] || 100
       start = 0
       while start < array_with_idmap.size
@@ -426,7 +425,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
 
         # Batch call
         log_info = id_update_only ? 'with only ids' : ''
-        Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Sending batch request to Connec! #{log_info} for #{self.class.normalize_connec_entity_name(connec_entity_name)}. Batch_request_size: #{batch_request[:ops].size}. Call_number: #{(start/request_per_call) + 1}")
+        Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Sending batch request to Connec! #{log_info} for #{self.class.normalize_connec_entity_name(connec_entity_name)}. Batch_request_size: #{batch_request[:ops].size}. Call_number: #{(start / request_per_call) + 1}")
         response = @connec_client.batch(batch_request)
         Maestrano::Connector::Rails::ConnectorLogger.log('debug', @organization, "Received batch response from Connec! for #{self.class.normalize_connec_entity_name(connec_entity_name)}: #{response}")
         raise "No data received from Connec! when trying to send batch request #{log_info} for #{self.class.connec_entity_name.pluralize}" unless response && !response.body.blank?
@@ -435,9 +434,9 @@ module Maestrano::Connector::Rails::Concerns::Entity
         # Parse batch response
         response['results'].each_with_index do |result, index|
           if result['status'] == 200
-            batch_entities[index][:idmap].update(connec_id: result['body'][self.class.normalize_connec_entity_name(connec_entity_name)]['id'].find{|id| id['provider'] == 'connec'}['id'], last_push_to_connec: Time.now, message: nil) unless id_update_only # id_update_only only apply for 200 as it's doing PUTs
+            batch_entities[index][:idmap].update(connec_id: result['body'][self.class.normalize_connec_entity_name(connec_entity_name)]['id'].find { |id| id['provider'] == 'connec' }['id'], last_push_to_connec: Time.now, message: nil) unless id_update_only # id_update_only only apply for 200 as it's doing PUTs
           elsif result['status'] == 201
-            batch_entities[index][:idmap].update(connec_id: result['body'][self.class.normalize_connec_entity_name(connec_entity_name)]['id'].find{|id| id['provider'] == 'connec'}['id'], last_push_to_connec: Time.now, message: nil)
+            batch_entities[index][:idmap].update(connec_id: result['body'][self.class.normalize_connec_entity_name(connec_entity_name)]['id'].find { |id| id['provider'] == 'connec' }['id'], last_push_to_connec: Time.now, message: nil)
           else
             Maestrano::Connector::Rails::ConnectorLogger.log('error', @organization, "Error while pushing to Connec!: #{result['body']}")
             batch_entities[index][:idmap].update(message: result['body'].to_s.truncate(255))
@@ -446,10 +445,10 @@ module Maestrano::Connector::Rails::Concerns::Entity
         start += request_per_call
       end
     end
-    
+
     def not_modified_since_last_push_to_connec?(idmap, entity)
       not_modified = idmap.last_push_to_connec && idmap.last_push_to_connec > self.class.last_update_date_from_external_entity_hash(entity)
-      Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Discard #{Maestrano::Connector::Rails::External::external_name} #{self.class.external_entity_name} : #{entity}") if not_modified
+      Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Discard #{Maestrano::Connector::Rails::External.external_name} #{self.class.external_entity_name} : #{entity}") if not_modified
       not_modified
     end
 
@@ -459,7 +458,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
       not_modified
     end
 
-    def before_date_filtering_limit?(entity, external=true)
+    def before_date_filtering_limit?(entity, external = true)
       @organization.date_filtering_limit && @organization.date_filtering_limit > (external ? self.class.creation_date_from_external_entity_hash(entity) : entity['created_at'])
     end
 
@@ -468,25 +467,21 @@ module Maestrano::Connector::Rails::Concerns::Entity
     end
 
     def solve_conflict(connec_entity, external_entities, external_entity_name, idmap)
-      if external_entity = external_entities.find{|external_entity| connec_entity['id'] == self.class.id_from_external_entity_hash(external_entity)}
-        # We keep the most recently updated entity
-        if @opts.has_key?(:connec_preemption)
-          keep_connec = @opts[:connec_preemption]
-        else
-          keep_connec = is_connec_more_recent?(connec_entity, external_entity)
-        end
+      external_entity = external_entities.find { |entity| connec_entity['id'] == self.class.id_from_external_entity_hash(entity) }
+      # No conflict
+      return map_connec_entity_with_idmap(connec_entity, external_entity_name, idmap) unless external_entity
 
-        if keep_connec
-          Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Conflict between #{Maestrano::Connector::Rails::External::external_name} #{external_entity_name} #{external_entity} and Connec! #{self.class.connec_entity_name} #{connec_entity}. Entity from Connec! kept")
-          external_entities.delete(external_entity)
-          map_connec_entity_with_idmap(connec_entity, external_entity_name, idmap)
-        else
-          Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Conflict between #{Maestrano::Connector::Rails::External::external_name} #{external_entity_name} #{external_entity} and Connec! #{self.class.connec_entity_name} #{connec_entity}. Entity from external kept")
-          nil
-        end
+      # Conflict
+      # We keep the most recently updated entity
+      keep_connec = @opts.key?(:connec_preemption) ? @opts[:connec_preemption] : is_connec_more_recent?(connec_entity, external_entity)
 
-      else
+      if keep_connec
+        Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Conflict between #{Maestrano::Connector::Rails::External.external_name} #{external_entity_name} #{external_entity} and Connec! #{self.class.connec_entity_name} #{connec_entity}. Entity from Connec! kept")
+        external_entities.delete(external_entity)
         map_connec_entity_with_idmap(connec_entity, external_entity_name, idmap)
+      else
+        Maestrano::Connector::Rails::ConnectorLogger.log('info', @organization, "Conflict between #{Maestrano::Connector::Rails::External.external_name} #{external_entity_name} #{external_entity} and Connec! #{self.class.connec_entity_name} #{connec_entity}. Entity from external kept")
+        nil
       end
     end
 
@@ -504,9 +499,8 @@ module Maestrano::Connector::Rails::Concerns::Entity
 
       response_hash = JSON.parse(response.body)
       Maestrano::Connector::Rails::ConnectorLogger.log('debug', @organization, "Received page #{page_number} for entity=#{self.class.connec_entity_name}, response=#{response_hash}")
-      raise "Received unrecognized Connec! data when trying to fetch page #{page_number} of #{self.class.normalized_connec_entity_name}: #{response_hash}" unless response_hash["#{self.class.normalized_connec_entity_name}"]
+      raise "Received unrecognized Connec! data when trying to fetch page #{page_number} of #{self.class.normalized_connec_entity_name}: #{response_hash}" unless response_hash[self.class.normalized_connec_entity_name]
 
       response_hash
     end
-
-end
+end