maestrano-connector-rails 0.0.1

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/app/controllers/maestrano/account/group_users_controller.rb

@@ -0,0 +1,20 @@
+class Maestrano::Account::GroupUsersController < Maestrano::Rails::WebHookController
+
+  # DELETE /maestrano/account/groups/cld-1/users/usr-1
+  # DELETE /maestrano/account/groups/cld-1/users/usr-1/tenant
+  # Remove a user from a group
+  def destroy
+    # Set the right uid based on Maestrano.param('sso.creation_mode')
+    user_uid = Maestrano.mask_user(params[:id], params[:group_id]) 
+    group_uid = params[:group_id]
+    
+    # Get the entities
+    user = User.find_by_provider_and_uid_and_tenant('maestrano', user_uid, params[:tenant])
+    organization = Organization.find_by_provider_and_uid_and_tenant('maestrano', group_uid, params[:tenant])
+    
+    # Remove the user from the organization
+    organization.remove_member(user)
+    
+    render json: {success: true}
+  end
+end

data/app/controllers/maestrano/account/groups_controller.rb

@@ -0,0 +1,22 @@
+class Maestrano::Account::GroupsController < Maestrano::Rails::WebHookController
+  
+  # DELETE /maestrano/account/groups/cld-1
+  # DELETE /maestrano/account/groups/cld-1/tenant
+  # Delete an entire group
+  def destroy
+    # id
+    group_uid = params[:id]
+    
+    # Get entity
+    organization = Organization.find_by_provider_and_uid_and_tenant('maestrano', group_uid, params[:tenant])
+    
+    # Delete all relations
+    organization.user_company_rels.delete_all
+    
+    # Delete the organization
+    organization.destroy
+    
+    # Respond
+    render json: {success: true}
+  end
+end

data/app/controllers/maestrano/application_controller.rb

@@ -0,0 +1,7 @@
+module Maestrano
+  class ApplicationController < ActionController::Base
+    include SessionHelper
+
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/maestrano/auth/saml_controller.rb

@@ -0,0 +1,31 @@
+class Maestrano::Auth::SamlController < Maestrano::Rails::SamlBaseController
+  #== POST '/maestrano/auth/saml/consume'
+  # Final phase of the Single Sign-On handshake. Find or create
+  # the required resources (user and group) and sign the user
+  # in
+  #
+  # This action is left to you to customize based on your application
+  # requirements. Below is presented a potential way of writing 
+  # the action.
+  #
+  # Assuming you have enabled maestrano on a user model
+  # called 'User' and a group model called 'Organization'
+  # the action could be written the following way
+  def consume
+    params[:tenant] ||= 'default'
+    user = Maestrano::Connector::Rails::User.find_or_create_for_maestrano(user_auth_hash, params[:tenant])
+    organization = Maestrano::Connector::Rails::Organization.find_or_create_for_maestrano(group_auth_hash, params[:tenant])
+    if user && organization
+      unless organization.member?(user)
+        organization.add_member(user)
+      end
+
+      session[:tenant] = params[:tenant]
+      session[:uid] = user.uid
+      session[:org_uid] = organization.uid
+      session[:"role_#{organization.uid}"] = user_group_rel_hash[:role]
+    end
+    
+    redirect_to main_app.root_path
+  end
+end

data/app/controllers/maestrano/sessions_controller.rb

@@ -0,0 +1,15 @@
+module Maestrano
+  class SessionsController < ApplicationController
+    # Logout
+    def destroy
+      session.delete(:uid)
+      session.delete(:"role_#{session[:org_uid]}")
+      session.delete(:org_uid)
+      session.delete(:tenant)
+      session.delete(:current_user_id)
+      @current_user = nil
+
+      redirect_to root_url
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+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
+
+    def current_organization
+      Organization.find_by(uid: session[:org_uid], tenant: session[:tenant])
+    end
+
+    def current_user
+      @current_user ||= User.find_by(uid: session[:uid], tenant: session[:tenant])
+    end
+
+  end
+end

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

@@ -0,0 +1,49 @@
+module Maestrano::Connector::Rails
+  class SynchronizationJob < Struct.new(:organization, :opts)
+
+    # Supported options:
+    #  * :forced => true  synchronization has been triggered manually (for logging purposes only)
+    #  * :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
+      ConnectorLogger.log('info', organization, "Start synchronization, opts=#{opts}")
+      current_synchronization = Synchronization.create_running(organization)
+
+      begin
+        last_synchronization = Synchronization.where(organization_id: organization.id, status: 'SUCCESS', partial: false).order(updated_at: :desc).first
+        connec_client = Maestrano::Connec::Client.new(organization.uid)
+        external_client = External.get_client(organization)
+
+        if opts[:only_entities]
+          ConnectorLogger.log('info', organization, "Synchronization is partial and will synchronize only #{opts[:only_entities].join(' ')}")
+          # The synchronization is marked as partial and will not be considered as the last-synchronization for the next sync
+          current_synchronization.set_partial
+          opts[:only_entities].each do |entity|
+            sync_entity(entity, organization, connec_client, external_client, last_synchronization, opts)
+          end
+        else
+          organization.synchronized_entities.select{|k, v| v}.keys.each do |entity|
+            sync_entity(entity.to_s, organization, connec_client, external_client, last_synchronization, opts)
+          end
+        end
+
+        ConnectorLogger.log('info', organization, "Finished synchronization, organization=#{organization.uid}, status=success")
+        current_synchronization.set_success
+      rescue => e
+        ConnectorLogger.log('info', organization, "Finished synchronization, organization=#{organization.uid}, status=error, message=#{e.message} backtrace=#{e.backtrace.join("\n\t")}")
+        current_synchronization.set_error(e.message)
+      end
+    end
+
+    def sync_entity(entity, organization, connec_client, external_client, last_synchronization, opts)
+      entity_instance = "Entities::#{entity.titleize.split.join}".constantize.new
+
+      external_entities = entity_instance.get_external_entities(external_client, last_synchronization, organization, opts)
+      connec_entities = entity_instance.get_connec_entities(connec_client, last_synchronization, organization, opts)
+      entity_instance.consolidate_and_map_data(connec_entities, external_entities, organization, opts)
+      entity_instance.push_entities_to_external(external_client, connec_entities, organization)
+      entity_instance.push_entities_to_connec(connec_client, external_entities, organization)
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+module Maestrano::Connector::Rails
+  class ComplexEntity
+
+    @@external_name = External.external_name
+
+    # -------------------------------------------------------------
+    #                   Complex specific methods
+    # Those methods needs to be implemented in each complex entity
+    # -------------------------------------------------------------
+    def connec_entities_names
+      raise "Not implemented"
+    end
+
+    def external_entities_names
+      raise "Not implemented"
+    end
+
+    # input :  {
+    #             connec_entities_names[0]: [unmapped_connec_entitiy1, unmapped_connec_entitiy2],
+    #             connec_entities_names[1]: [unmapped_connec_entitiy3, unmapped_connec_entitiy4]
+    #          }
+    # output : {
+    #             connec_entities_names[0]: {
+    #               external_entities_names[0]: [unmapped_connec_entitiy1, unmapped_connec_entitiy2]
+    #             },
+    #             connec_entities_names[1]: {
+    #               external_entities_names[0]: [unmapped_connec_entitiy3],
+    #               external_entities_names[1]: [unmapped_connec_entitiy4]
+    #             }
+    #          }
+    def connec_model_to_external_model!(connec_hash_of_entities)
+      raise "Not implemented"
+    end
+
+    # input :  {
+    #             external_entities_names[0]: [unmapped_external_entity1}, unmapped_external_entity2],
+    #             external_entities_names[1]: [unmapped_external_entity3}, unmapped_external_entity4]
+    #          }
+    # output : {
+    #             external_entities_names[0]: {
+    #               connec_entities_names[0]: [unmapped_external_entity1],
+    #               connec_entities_names[1]: [unmapped_external_entity2]
+    #             },
+    #             external_entities_names[1]: {
+    #               connec_entities_names[0]: [unmapped_external_entity3, unmapped_external_entity4]
+    #             }
+    #           }
+    def external_model_to_connec_model!(external_hash_of_entities)
+      raise "Not implemented"
+    end
+
+    # -------------------------------------------------------------
+    #          General methods
+    # -------------------------------------------------------------
+    def map_to_external_with_idmap(entity, organization, connec_entity_name, external_entity_name, sub_entity_instance)
+      idmap = IdMap.find_by(connec_id: entity['id'], connec_entity: connec_entity_name.downcase, external_entity: external_entity_name.downcase, organization_id: organization.id)
+
+      if idmap && idmap.last_push_to_external && idmap.last_push_to_external > entity['updated_at']
+        ConnectorLogger.log('info', organization, "Discard Connec! #{connec_entity_name} : #{entity}")
+        nil
+      else
+        {entity: sub_entity_instance.map_to(external_entity_name, entity, organization), idmap: idmap || IdMap.create(connec_id: entity['id'], connec_entity: connec_entity_name.downcase, external_entity: external_entity_name.downcase, organization_id: organization.id)}
+      end
+    end
+
+    # -------------------------------------------------------------
+    #          Entity equivalent methods
+    # -------------------------------------------------------------
+    def get_connec_entities(client, last_synchronization, organization, opts={})
+      entities = ActiveSupport::HashWithIndifferentAccess.new
+
+      self.connec_entities_names.each do |connec_entity_name|
+        sub_entity_instance = "Entities::SubEntities::#{connec_entity_name.titleize.split.join}".constantize.new
+        entities[connec_entity_name] = sub_entity_instance.get_connec_entities(client, last_synchronization, organization, opts)
+      end
+      entities
+    end
+
+    def get_external_entities(client, last_synchronization, organization, opts={})
+      entities = ActiveSupport::HashWithIndifferentAccess.new
+
+      self.external_entities_names.each do |external_entity_name|
+        sub_entity_instance = "Entities::SubEntities::#{external_entity_name.titleize.split.join}".constantize.new
+        entities[external_entity_name] = sub_entity_instance.get_external_entities(client, last_synchronization, organization, opts)
+      end
+      entities
+    end
+
+    def consolidate_and_map_data(connec_entities, external_entities, organization, opts)
+      external_model_to_connec_model!(external_entities)
+      connec_model_to_external_model!(connec_entities)
+
+      external_entities.each do |external_entity_name, entities_in_connec_model|
+        entities_in_connec_model.each do |connec_entity_name, entities|
+          sub_entity_instance = "Entities::SubEntities::#{external_entity_name.titleize.split.join}".constantize.new
+
+          entities.map!{|entity|
+            idmap = IdMap.find_by(external_id: sub_entity_instance.get_id_from_external_entity_hash(entity), external_entity: external_entity_name.downcase, connec_entity: connec_entity_name.downcase, organization_id: organization.id)
+
+            # No idmap: creating one, nothing else to do
+            unless idmap
+              next {entity: sub_entity_instance.map_to(connec_entity_name, entity, organization), idmap: IdMap.create(external_id: sub_entity_instance.get_id_from_external_entity_hash(entity), external_entity: external_entity_name.downcase, connec_entity: connec_entity_name.downcase, organization_id: organization.id)}
+            end
+
+            # Entity has not been modified since its last push to connec!
+            if idmap.last_push_to_connec && idmap.last_push_to_connec > sub_entity_instance.get_last_update_date_from_external_entity_hash(entity)
+              ConnectorLogger.log('info', organization, "Discard #{@@external_name} #{external_entity_name} : #{entity}")
+              next nil
+            end
+
+            equivalent_connec_entities = connec_entities[connec_entity_name][external_entity_name] || []
+            # Check for conflict with entities from connec!
+            if idmap.connec_id && connec_entity = equivalent_connec_entities.detect{|connec_entity| connec_entity['id'] == idmap.connec_id}
+              # We keep the most recently updated entity
+              if !opts[:connec_preemption].nil?
+                keep_external = !opts[:connec_preemption]
+              else
+                keep_external = connec_entity['updated_at'] < sub_entity_instance.get_last_update_date_from_external_entity_hash(entity)
+              end
+
+              if keep_external
+                ConnectorLogger.log('info', organization, "Conflict between #{@@external_name} #{external_entity_name} #{entity} and Connec! #{connec_entity_name} #{connec_entity}. Entity from #{@@external_name} kept")
+                equivalent_connec_entities.delete(connec_entity)
+                {entity: sub_entity_instance.map_to(connec_entity_name, entity, organization), idmap: idmap}
+              else
+                ConnectorLogger.log('info', organization, "Conflict between #{@@external_name} #{external_entity_name} #{entity} and Connec! #{connec_entity_name} #{connec_entity}. Entity from Connec! kept")
+                nil
+              end
+
+            else
+              {entity: sub_entity_instance.map_to(connec_entity_name, entity, organization), idmap: idmap}
+            end
+          }.compact!
+        end
+      end
+
+      connec_entities.each do |connec_entity_name, entities_in_external_model|
+        entities_in_external_model.each do |external_entity_name, entities|
+          sub_entity_instance = "Entities::SubEntities::#{connec_entity_name.titleize.split.join}".constantize.new
+          entities.map!{|entity|
+            self.map_to_external_with_idmap(entity, organization, connec_entity_name, external_entity_name, sub_entity_instance)
+          }.compact!
+        end
+      end
+    end
+
+    # input : {
+    #             external_entities_names[0]: {
+    #               connec_entities_names[0]: [mapped_external_entity1],
+    #               connec_entities_names[1]: [mapped_external_entity2]
+    #             },
+    #             external_entities_names[1]: {
+    #               connec_entities_names[0]: [mapped_external_entity3, mapped_external_entity4]
+    #             }
+    #          }
+    def push_entities_to_connec(connec_client, mapped_external_entities_with_idmaps, organization)
+      mapped_external_entities_with_idmaps.each do |external_entity_name, entities_in_connec_model|
+        sub_entity_instance = "Entities::SubEntities::#{external_entity_name.titleize.split.join}".constantize.new
+        entities_in_connec_model.each do |connec_entity_name, mapped_entities_with_idmaps|
+          sub_entity_instance.push_entities_to_connec_to(connec_client, mapped_entities_with_idmaps, connec_entity_name, organization)
+        end
+      end
+    end
+
+
+    def push_entities_to_external(external_client, mapped_connec_entities_with_idmaps, organization)
+      mapped_connec_entities_with_idmaps.each do |connec_entity_name, entities_in_external_model|
+        sub_entity_instance = "Entities::SubEntities::#{connec_entity_name.titleize.split.join}".constantize.new
+        entities_in_external_model.each do |external_entity_name, mapped_entities_with_idmaps|
+          sub_entity_instance.push_entities_to_external_to(external_client, mapped_entities_with_idmaps, external_entity_name, organization)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+module Maestrano::Connector::Rails::Concerns::Entity
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    # Return an array of all the entities that the connector can synchronize
+    # If you add new entities, you need to generate
+    # a migration to add them to existing organizations
+    def entities_list
+      raise "Not implemented"
+    end
+  end
+
+  @@external_name = Maestrano::Connector::Rails::External.external_name
+
+  # ----------------------------------------------
+  #                 Mapper methods
+  # ----------------------------------------------
+  # Map a Connec! entity to the external format
+  def map_to_external(entity, organization)
+    self.mapper_class.normalize(entity)
+  end
+
+  # Map an external entity to Connec! format
+  def map_to_connec(entity, organization)
+    self.mapper_class.denormalize(entity)
+  end
+
+  # ----------------------------------------------
+  #                 Connec! methods
+  # ----------------------------------------------
+  def get_connec_entities(client, last_synchronization, organization, opts={})
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Fetching Connec! #{self.connec_entity_name}")
+
+    entities = []
+
+    # Fetch first page
+    if last_synchronization.blank? || opts[:full_sync]
+      response = client.get("/#{self.connec_entity_name.downcase.pluralize}")
+    else
+      query_param = URI.encode("$filter=updated_at gt '#{last_synchronization.updated_at.iso8601}'")
+      response = client.get("/#{self.connec_entity_name.downcase.pluralize}?#{query_param}")
+    end
+    raise "No data received from Connec! when trying to fetch #{self.connec_entity_name.pluralize}" unless response
+
+    response_hash = JSON.parse(response.body)
+    if response_hash["#{self.connec_entity_name.downcase.pluralize}"]
+      entities << response_hash["#{self.connec_entity_name.downcase.pluralize}"]
+    else
+      raise "Received unrecognized Connec! data when trying to fetch #{self.connec_entity_name.pluralize}"
+    end
+
+    # Fetch subsequent pages
+    while response_hash['pagination'] && response_hash['pagination']['next']
+      # ugly way to convert https://api-connec/api/v2/group_id/organizations?next_page_params to /organizations?next_page_params
+      next_page = response_hash['pagination']['next'].gsub(/^(.*)\/#{self.connec_entity_name.downcase.pluralize}/, self.connec_entity_name.downcase.pluralize)
+      response = client.get(next_page)
+
+      raise "No data received from Connec! when trying to fetch subsequent page of #{self.connec_entity_name.pluralize}" unless response
+      response_hash = JSON.parse(response.body)
+      if response_hash["#{self.connec_entity_name.downcase.pluralize}"]
+        entities << response_hash["#{self.connec_entity_name.downcase.pluralize}"]
+      else
+        raise "Received unrecognized Connec! data when trying to fetch subsequent page of #{self.connec_entity_name.pluralize}"
+      end
+    end
+
+    entities = entities.flatten
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Received data: Source=Connec!, Entity=#{self.connec_entity_name}, Data=#{entities}")
+    entities
+  end
+
+  def push_entities_to_connec(connec_client, mapped_external_entities_with_idmaps, organization)
+    self.push_entities_to_connec_to(connec_client, mapped_external_entities_with_idmaps, self.connec_entity_name, organization)
+  end
+
+  def push_entities_to_connec_to(connec_client, mapped_external_entities_with_idmaps, connec_entity_name, organization)
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Sending #{@@external_name} #{self.external_entity_name.pluralize} to Connec! #{connec_entity_name.pluralize}")
+    mapped_external_entities_with_idmaps.each do |mapped_external_entity_with_idmap|
+      external_entity = mapped_external_entity_with_idmap[:entity]
+      idmap = mapped_external_entity_with_idmap[:idmap]
+
+      if idmap.connec_id.blank?
+        connec_entity = self.create_entity_to_connec(connec_client, external_entity, connec_entity_name, organization)
+        idmap.update_attributes(connec_id: connec_entity['id'], connec_entity: connec_entity_name.downcase, last_push_to_connec: Time.now)
+      else
+        connec_entity = self.update_entity_to_connec(connec_client, external_entity, idmap.connec_id, connec_entity_name, organization)
+        idmap.update_attributes(last_push_to_connec: Time.now)
+      end
+    end
+  end
+
+  def create_entity_to_connec(connec_client, mapped_external_entity, connec_entity_name, organization)
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Sending create #{connec_entity_name}: #{mapped_external_entity} to Connec!")
+    response = connec_client.post("/#{connec_entity_name.downcase.pluralize}", { "#{connec_entity_name.downcase.pluralize}".to_sym => mapped_external_entity })
+    raise "No response received from Connec! when trying to create a #{self.connec_entity_name}" unless response
+    JSON.parse(response.body)["#{connec_entity_name.downcase.pluralize}"]
+  end
+
+  def update_entity_to_connec(connec_client, mapped_external_entity, connec_id, connec_entity_name, organization)
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Sending update #{connec_entity_name}: #{mapped_external_entity} to Connec!")
+    response = connec_client.put("/#{connec_entity_name.downcase.pluralize}/#{connec_id}", { "#{connec_entity_name.downcase.pluralize}".to_sym => mapped_external_entity })
+    raise "No response received from Connec! when trying to update a #{self.connec_entity_name}" unless response
+  end
+
+  def map_to_external_with_idmap(entity, organization)
+    idmap = Maestrano::Connector::Rails::IdMap.find_by(connec_id: entity['id'], connec_entity: self.connec_entity_name.downcase, organization_id: organization.id)
+
+    if idmap && idmap.last_push_to_external && idmap.last_push_to_external > entity['updated_at']
+      Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard Connec! #{self.connec_entity_name} : #{entity}")
+      nil
+    else
+      {entity: self.map_to_external(entity, organization), idmap: idmap || Maestrano::Connector::Rails::IdMap.create(connec_id: entity['id'], connec_entity: self.connec_entity_name.downcase, organization_id: organization.id)}
+    end
+  end
+
+  # ----------------------------------------------
+  #                 External methods
+  # ----------------------------------------------
+  def get_external_entities(client, last_synchronization, organization, opts={})
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Fetching #{@@external_name} #{self.external_entity_name.pluralize}")
+    raise "Not implemented"
+  end
+
+  def push_entities_to_external(external_client, mapped_connec_entities_with_idmaps, organization)
+    push_entities_to_external_to(external_client, mapped_connec_entities_with_idmaps, self.external_entity_name, organization)
+  end
+
+  def push_entities_to_external_to(external_client, mapped_connec_entities_with_idmaps, external_entity_name, organization)
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Sending Connec! #{self.connec_entity_name.pluralize} to #{@@external_name} #{external_entity_name.pluralize}")
+    mapped_connec_entities_with_idmaps.each do |mapped_connec_entity_with_idmap|
+      self.push_entity_to_external(external_client, mapped_connec_entity_with_idmap, external_entity_name, organization)
+    end
+  end
+
+  def push_entity_to_external(external_client, mapped_connec_entity_with_idmap, external_entity_name, organization)
+    idmap = mapped_connec_entity_with_idmap[:idmap]
+    connec_entity = mapped_connec_entity_with_idmap[:entity]
+
+    if idmap.external_id.blank?
+      external_id = self.create_entity_to_external(external_client, connec_entity, external_entity_name, organization)
+      idmap.update_attributes(external_id: external_id, external_entity: external_entity_name.downcase, last_push_to_external: Time.now)
+    else
+      self.update_entity_to_external(external_client, connec_entity, idmap.external_id, external_entity_name, organization)
+      idmap.update_attributes(last_push_to_external: Time.now)
+    end
+  end
+
+  def create_entity_to_external(client, mapped_connec_entity, external_entity_name, organization)
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Sending create #{external_entity_name}: #{mapped_connec_entity} to #{@@external_name}")
+    raise "Not implemented"
+  end
+
+  def update_entity_to_external(client, mapped_connec_entity, external_id, external_entity_name, organization)
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Sending update #{external_entity_name} (id=#{external_id}): #{mapped_connec_entity} to #{@@external_name}")
+    raise "Not implemented"
+  end
+
+  def get_id_from_external_entity_hash(entity)
+    raise "Not implemented"
+  end
+
+  def get_last_update_date_from_external_entity_hash(entity)
+    raise "Not implemented"
+  end
+
+  # ----------------------------------------------
+  #                 General methods
+  # ----------------------------------------------
+  # * Discards entities that do not need to be pushed because they have not been updated since their last push
+  # * Discards entities from one of the two source in case of conflict
+  # * Maps not discarded entities and associates them with their idmap, or create one if there isn't any
+  def consolidate_and_map_data(connec_entities, external_entities, organization, opts={})
+    external_entities.map!{|entity|
+      idmap = Maestrano::Connector::Rails::IdMap.find_by(external_id: self.get_id_from_external_entity_hash(entity), external_entity: self.external_entity_name.downcase, organization_id: organization.id)
+
+      # No idmap: creating one, nothing else to do
+      unless idmap
+        next {entity: self.map_to_connec(entity, organization), idmap: Maestrano::Connector::Rails::IdMap.create(external_id: self.get_id_from_external_entity_hash(entity), external_entity: self.external_entity_name.downcase, organization_id: organization.id)}
+      end
+
+      # Entity has not been modified since its last push to connec!
+      if idmap.last_push_to_connec && idmap.last_push_to_connec > self.get_last_update_date_from_external_entity_hash(entity)
+        Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard #{@@external_name} #{self.external_entity_name} : #{entity}")
+        next nil
+      end
+
+      # Check for conflict with entities from connec!
+      if idmap.connec_id && connec_entity = connec_entities.detect{|connec_entity| connec_entity['id'] == idmap.connec_id}
+        # We keep the most recently updated entity
+        if !opts[:connec_preemption].nil?
+          keep_external = !opts[:connec_preemption]
+        else
+          keep_external = connec_entity['updated_at'] < self.get_last_update_date_from_external_entity_hash(entity)
+        end
+
+        if keep_external
+          Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Conflict between #{@@external_name} #{self.external_entity_name} #{entity} and Connec! #{self.connec_entity_name} #{connec_entity}. Entity from #{@@external_name} kept")
+          connec_entities.delete(connec_entity)
+          {entity: self.map_to_connec(entity, organization), idmap: idmap}
+        else
+          Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Conflict between #{@@external_name} #{self.external_entity_name} #{entity} and Connec! #{self.connec_entity_name} #{connec_entity}. Entity from Connec! kept")
+          nil
+        end
+
+      else
+        {entity: self.map_to_connec(entity, organization), idmap: idmap}
+      end
+    }.compact!
+
+    connec_entities.map!{|entity|
+      self.map_to_external_with_idmap(entity, organization)
+    }.compact!
+  end
+
+
+  # ----------------------------------------------
+  #             Entity specific methods
+  # Those methods need to be define in each entity
+  # ----------------------------------------------
+  def connec_entity_name
+    raise "Not implemented"
+  end
+
+  def external_entity_name
+    raise "Not implemented"
+  end
+
+  def mapper_class
+    raise "Not implemented"
+  end
+end