maestrano-connector-rails 0.2.20 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 641c5c4a44a4f83f3c44ed2c5e23a474eba48abb
-  data.tar.gz: 9912810a2b3d6986e68ba89d19d5068e12daaade
+  metadata.gz: 2f0083a436b601632884149aff3e8111b01ba1a6
+  data.tar.gz: c0e95181ea0b2a66b137e2ec6047ddd4bdc40f2c
 SHA512:
-  metadata.gz: 3ad9efcebceb9e3506693ae02d101ee61efdd103d5f04c62ab97b9764c890da72410d9440b8bcc84235beef2bd9431926d3e13cab6e021e524158f8a54a75698
-  data.tar.gz: cdd4bc5ac76e057c4b4249c66f18e88c6c4eba76b020e1fe211563c1074f64b0e61a4ed575fe881aff49cfbca1ed69d9bd7c74f07ea467d49c39ced3c87f8a09
+  metadata.gz: 41fceaf54ad78bdca9cbc7dd6dc07f5d22b67ad6ce532b5cf39d59aa57faccc57f3c657371b75a359570e58b648e3b59cfb0d2d271db4c13c1e8dd9f712e37fa
+  data.tar.gz: 639653b1337385bb1b60d45e160b2bb9db96308c4bb023dbfc1a86942e6fdabc78c923351884fed05f2fb83a938b38e4c76ad7bc385a1405a1bd9db69df306a5

data/README.md

@@ -8,162 +8,6 @@
 </p>
 
 Maestrano Connector is a Rails Engine that bootstraps the implementation of data syncrhonization between an external application API and the Maestrano ecosystem.
-
 Maestrano Connector Integration is currently in closed beta. Want to know more? Send us an email to <contact@maestrano.com>.
 
-- - -
-
-1. [Getting Setup](#getting-setup)
-2. [Getting Started](#getting-started)
-  * [Integration with Maestrano](#integration-with-maestrano)
-  * [Integration with the external application](#integration-with-the-external-application)
-3. [Preparing synchronizations](#preparing-synchronizations)
-  * [External.rb](#external.rb)
-  * [Entity.rb](#entity.rb)
-  * [Mapping entities](#mapping-entities)
-4. [Pages controllers and views](#pages-controllers-and-views)
-5. [Complex entities](#complex-entities)
-6. [Webhooks](#Webhooks)
-
-- - -
-
-## Getting Setup
-Before integrating with us you will need to have your application registered on the Maestrano platform. Please refer to the online documentation we provide: https://maestrano.atlassian.net/wiki/display/CONNECAPIV2/Maestrano+Developers
-
-## Getting Started
-Create a new rails application using the connector template. The template works with both Ruby 2.2 and jRuby 9.0.4.0, you will be asked which one you want to use.
-```console
-rails new <project_name> -m https://raw.githubusercontent.com/Maestrano/maestrano-connector-rails/master/template/maestrano-connector-template.rb
-```
-
-If and only if you have an error in the template's rails generate step, you'll need to re-run the following command in your project folder:
-```console
-bundle
-rails g connector:install
-rake db:migrate
-```
-
-### Integration with Maestrano
-
-First thing to do is to put your Connec!™ API keys in the config/application.yml:
-```ruby
-connec_api_id: 'API_ID'
-connec_api_key: 'API_KEY'
-```
-
-The next thing you need to do is to set your configuration in config/initializers/maestrano.rb. You will need to define where your application will be publicly hosted:
-```ruby
-config.app.host = 'http://path_to_app'
-```
-The rest of the config has default values, so you can take a look but you don't really need to change anything else.
-For a more detailed configuration, please refer to https://github.com/maestrano/maestrano-ruby#configuration
-
-Please note that the connectors support multi-tenancy, so you may have to set up configuration for tenants other than the Maestrano platform (the default one).
-
-These configuration are automatically retrieved by Maestrano via a metadata endpoint that is provided by the gem, so you're all setup as it is.
-
-Time to test! If your launch your application (please make sure that you launch the application on the same path as the one in the config file). If you click on the 'Link your Maestrano account' link on your connector home page, you should be able to do a full SSO process with Maestrano.
-
-### Integration with the external application
-
-Now that you're all setup with Maestrano, it's time to take a look at the external application you are integrating with. Hopefully it has one or several gems for both the authentication process and the API calls. In any case, you'll need to take a look at their documentation.
-
-You will probably have to request API keys and adds them to the application.yml alongside the Maestrano's ones.
-
-The connector engine is thought to be able to use oauth authentication processes, and an oauth_controller is provided as an example. Please note that it is only an example and you will have to implements most of it, and to create the needed routes, and use them in the provided view.
-
-If all went well, you should now be able to use the 'Link this company to...' link on the home page. Congrats!
-
-## Preparing synchronizations
-
-The aim of the connector is to perform synchronizations between Connec!™ and the external application, meaning fetching data on both ends, process them, and push the result to the relevant parties. The Connec!™ part and the synchronization process itself is handled by the engine, so all you have to do is to implements some methods to bridge the calls to the external application.
-
-### external.rb
-
-First file to look for is `models/maestrano/connector/rails/external.rb`. It contains two methods that you need to implement:
-
-* external_name, which is used for logging purpose only, and should only return the name of the external application, e.g.
-```ruby
-def self.external_name
-  'This awesome CRM'
-end
-```
-* get_client, which should return either the external application gem api client, or, in the worst case, a custom HTTParty client.
-
-
-### entity.rb
-
-The second important file is `models/maestrano/connector/rails/entity.rb`. It contains a method to declare the entities synchronizable by your connector (more on that later), some methods to retrieve and send data to the external application API, and lastly two methods to extract `id` and `timestamps` from the entity format sent by the external application.
-
-The details of each methods are explained in the entity.rb file provided.
-
-### Mapping entities
-
-Now that you're all setup with both Connec!™ and the external application, it's time to decide which entities (contacts, accounts, events, ...) you want to synchronize. For each type of entity your connector will synchronize, you will need to create a class that inherits from `Maestrano::Connector::Rails::Entity`.
-
-An example of such a class in provided in the models/entities/ folder, and demonstrates which methods you'll need to implements for each entity. The main thing to do is the mapping between the external entity and the Connec!™ entity. For the mapping, we use the hash_mapper gem (<https://github.com/ismasan/hash_mapper>).
-
-This type of entity class enable one-to-one model correspondance. For more complex needs, please refer to the complex entity section below.
-
-You'll find the connec API documentation here: <http://maestrano.github.io/connec/>, and should also refer to the external application API documentation.
-
-Also don't forget that each entity your connector synchronize should be declared in the entity.rb class, and, because the synchronizable entities are stored in the local database for each organization, you'll need to create a migration for exisiting organization if you add an new entity.
-
-#### Overriding methods
-
-To fit each entity specific need, you can overide all methods define in the entity class, including those implemented by the engine.
-
-In particular, you will probably need to override the mapping methods to realize reference between entities (this can't be done during the mapping because it requires the organization id).
-
-For example:
-```ruby
-def map_to_connec(entity, organization)
-  if id = entity['AccountId']
-    idmap = Maestrano::Connector::Rails::IdMap.find_by(external_entity: 'account', external_id: id, organization_id: organization.id, connec_entity: 'organization')
-    entity['AccountId'] = idmap ? idmap.connec_id : ''
-  end
-  self.mapper_class.denormalize(entity)
-end
-```
-
-### Triggering synchronizations
-Performing the synchronization of all the linked organizations can be triggered by executing
-```ruby
-Maestrano::Connector::Rails::AllSynchronizationsJob
-```
-
-The synchronization of a specific organization can be performed by executing
-```ruby
-Maestrano::Connector::Rails::SynchronizationJob.perform_later(organization, {})
-```
-
-## Pages controllers and views
-
-The home and admin pages views and controllers are provided as example, but you are free to customize them and the styling is left for you to do.
-
-## Complex entities
-
-For more complex correspondances, like one-to-many or many-to-many ones, you can use the complex entity workflow. To see how it works, you can run
-```console
-rails g connector:complex_entity
-```
-
-This will generate some example files demonstrating a one-to-many correspondance between Connec!™ person and external contact and lead data models.
-
-The complex entities workflow uses two methods to pre-process data which you have to implements for each complex entity (see contact_and_lead.rb). They are called before the mapping step, and you can use them to perform any data model specific operations.
-
-## Webhooks
-
-Connec!™ issues webhooks each time an entity is created or updated. This allows real time integration from Connec!™ to the application you're integrating with. All you have to do is subscribe to the webhooks on the entities your interested in (in your Maestrano.rb file), everything else is magically handled by the gem.
-
-If the application you're integrating with support webhooks, you can and should use them to allow a full real time integration. The gem provide a job to help you do that. It will perform the necessary checks, mappings and then push the entities to Connec!™. All you have to do is build a controller and config the necessary routes to catch the webhook, and call this job. For example:
-```ruby
-class ExternalWebhooksController < ApplicationController
-  def notification
-    organization = # find organization from webhook params
-    Maestrano::Connector::Rails::PushToConnecJob.perform_later(organization, params[:notif][:name], parmas[:notif][:objects])
-  end
-end
-```
-
-If you have questions, please contact the technical team <developers@maestrano.com>.
+You can find the documentation [here](https://maestrano.atlassian.net/wiki/display/CONNECAPIV2/Maestrano+connector+framework+-+rails). See also some generic documentation about integration with Maestrano [here](https://maestrano.atlassian.net/wiki/display/CONNECAPIV2/Maestrano+Developers).

data/VERSION

@@ -1 +1 @@
-0.2.20
+0.3.0

data/app/controllers/maestrano/connec_controller.rb

@@ -16,7 +16,7 @@ class Maestrano::ConnecController < Maestrano::Rails::WebHookController
 
                 # Build expected input for consolidate_and_map_data
                 if entity_instance_hash[:is_complex]
-                  mapped_entity = entity_instance.consolidate_and_map_data(Hash[ *entity_instance.connec_entities_names.collect{|name| name.downcase.pluralize == entity_name ? [name, [entity]] : [ name, []]}.flatten(1) ], Hash[ *entity_instance.external_entities_names.collect{|name| [ name, []]}.flatten(1) ], organization, {})
+                  mapped_entity = entity_instance.consolidate_and_map_data(Hash[ *entity_instance.class.connec_entities_names.collect{|name| name.parameterize('_').pluralize == entity_name ? [name, [entity]] : [ name, []]}.flatten(1) ], Hash[ *entity_instance.class.external_entities_names.collect{|name| [ name, []]}.flatten(1) ], organization, {})
                 else
                   mapped_entity = entity_instance.consolidate_and_map_data([entity], [], organization, {})
                 end
@@ -44,11 +44,11 @@ class Maestrano::ConnecController < Maestrano::Rails::WebHookController
   private
     def find_entity_instance(entity_name)
       Maestrano::Connector::Rails::Entity.entities_list.each do |entity_name_from_list|
-        instance = "Entities::#{entity_name_from_list.singularize.titleize.split.join}".constantize.new
-        if instance.methods.include?('connec_entities_names'.to_sym)
-          return {instance: instance, is_complex: true, name: entity_name_from_list} if instance.connec_entities_names.map{|n| n.pluralize.downcase}.include?(entity_name)
-        elsif instance.methods.include?('connec_entity_name'.to_sym)
-          return {instance: instance, is_complex: false, name: entity_name_from_list} if instance.normalized_connec_entity_name == entity_name
+        clazz = "Entities::#{entity_name_from_list.singularize.titleize.split.join}".constantize
+        if clazz.methods.include?('connec_entities_names'.to_sym)
+          return {instance: clazz.new, is_complex: true, name: entity_name_from_list} if clazz.connec_entities_names.map{|n| n.parameterize('_').pluralize}.include?(entity_name)
+        elsif clazz.methods.include?('connec_entity_name'.to_sym)
+          return {instance: clazz.new, is_complex: false, name: entity_name_from_list} if clazz.normalized_connec_entity_name == entity_name
         end
       end
       nil

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

@@ -12,9 +12,8 @@ module Maestrano::Connector::Rails
         if entity_instance_hash = find_entity_instance(external_entity_name)
           entity_instance = entity_instance_hash[:instance]
           next unless organization.synchronized_entities[entity_instance_hash[:name].to_sym]
-
           if entity_instance_hash[:is_complex]
-            mapped_entities = entity_instance.consolidate_and_map_data(Hash[ *entity_instance.connec_entities_names.collect{|name| [ name, []]}.flatten(1) ], Hash[ *entity_instance.external_entities_names.collect{|name| name == external_entity_name ? [name, entities] : [ name, []]}.flatten(1) ], organization, {})
+            mapped_entities = entity_instance.consolidate_and_map_data(Hash[ *entity_instance.class.connec_entities_names.collect{|name| [ name, []]}.flatten(1) ], Hash[ *entity_instance.class.external_entities_names.collect{|name| name == external_entity_name ? [name, entities] : [ name, []]}.flatten(1) ], organization, {})
           else
             mapped_entities = entity_instance.consolidate_and_map_data([], entities, organization, {})
           end
@@ -29,11 +28,11 @@ module Maestrano::Connector::Rails
     private
       def find_entity_instance(entity_name)
         Maestrano::Connector::Rails::Entity.entities_list.each do |entity_name_from_list|
-          instance = "Entities::#{entity_name_from_list.singularize.titleize.split.join}".constantize.new
-          if instance.methods.include?('external_entities_names'.to_sym)
-            return {instance: instance, is_complex: true, name: entity_name_from_list} if instance.external_entities_names.include?(entity_name)
-          elsif instance.methods.include?('external_entity_name'.to_sym)
-            return {instance: instance, is_complex: false, name: entity_name_from_list} if instance.external_entity_name == entity_name
+          clazz = "Entities::#{entity_name_from_list.singularize.titleize.split.join}".constantize
+          if clazz.methods.include?('external_entities_names'.to_sym)
+            return {instance: clazz.new, is_complex: true, name: entity_name_from_list} if clazz.external_entities_names.include?(entity_name)
+          elsif clazz.methods.include?('external_entity_name'.to_sym)
+            return {instance: clazz.new, is_complex: false, name: entity_name_from_list} if clazz.external_entity_name == entity_name
           end
         end
         nil

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

@@ -49,11 +49,13 @@ module Maestrano::Connector::Rails
     def sync_entity(entity_name, organization, connec_client, external_client, last_synchronization, opts)
       entity_instance = "Entities::#{entity_name.titleize.split.join}".constantize.new
 
+      entity_instance.before_sync(connec_client, external_client, organization, opts)
       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)
       mapped_entities = entity_instance.consolidate_and_map_data(connec_entities, external_entities, organization, opts)
       entity_instance.push_entities_to_external(external_client, mapped_entities[:connec_entities], organization)
       entity_instance.push_entities_to_connec(connec_client, mapped_entities[:external_entities], organization)
+      entity_instance.after_sync(connec_client, external_client, organization, opts)
     end
   end
 end

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

@@ -1,18 +1,18 @@
 module Maestrano::Connector::Rails::Concerns::ComplexEntity
   extend ActiveSupport::Concern
 
-  @@external_name = Maestrano::Connector::Rails::External.external_name
-
   # -------------------------------------------------------------
   #                   Complex specific methods
   # Those methods needs to be implemented in each complex entity
   # -------------------------------------------------------------
-  def connec_entities_names
-    raise "Not implemented"
-  end
+  module ClassMethods
+    def connec_entities_names
+      raise "Not implemented"
+    end
 
-  def external_entities_names
-    raise "Not implemented"
+    def external_entities_names
+      raise "Not implemented"
+    end
   end
 
   # input :  {
@@ -53,18 +53,18 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
   #          General methods
   # -------------------------------------------------------------
   def map_to_external_with_idmap(entity, organization, external_entity_name, sub_entity_instance)
-    idmap = sub_entity_instance.find_idmap({connec_id: entity['id'], external_entity: external_entity_name, organization_id: organization.id})
+    idmap = sub_entity_instance.class.find_idmap({connec_id: entity['id'], external_entity: external_entity_name, organization_id: organization.id})
 
     if idmap
-      idmap.update(name: sub_entity_instance.object_name_from_connec_entity_hash(entity))
+      idmap.update(name: sub_entity_instance.class.object_name_from_connec_entity_hash(entity))
       if (!idmap.to_external) || idmap.last_push_to_external && idmap.last_push_to_external > entity['updated_at']
-        Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard Connec! #{sub_entity_instance.entity_name} : #{entity}")
+        Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard Connec! #{sub_entity_instance.class.entity_name} : #{entity}")
         nil
       else
         {entity: sub_entity_instance.map_to(external_entity_name, entity, organization), idmap: idmap}
       end
     else
-      {entity: sub_entity_instance.map_to(external_entity_name, entity, organization), idmap: sub_entity_instance.create_idmap_from_connec_entity(entity, external_entity_name, organization)}
+      {entity: sub_entity_instance.map_to(external_entity_name, entity, organization), idmap: sub_entity_instance.class.create_idmap_from_connec_entity(entity, external_entity_name, organization)}
     end
   end
 
@@ -100,20 +100,20 @@ module Maestrano::Connector::Rails::Concerns::ComplexEntity
         sub_entity_instance = "Entities::SubEntities::#{external_entity_name.titleize.split.join}".constantize.new
 
         entities.map!{|entity|
-          idmap = sub_entity_instance.find_idmap(external_id: sub_entity_instance.get_id_from_external_entity_hash(entity), connec_entity: connec_entity_name, organization_id: organization.id)
+          idmap = sub_entity_instance.class.find_idmap(external_id: sub_entity_instance.class.id_from_external_entity_hash(entity), connec_entity: connec_entity_name, organization_id: organization.id)
 
           # No idmap: creating one, nothing else to do
           if idmap
-            idmap.update(name: sub_entity_instance.object_name_from_external_entity_hash(entity))
+            idmap.update(name: sub_entity_instance.class.object_name_from_external_entity_hash(entity))
           else
-            next {entity: sub_entity_instance.map_to(connec_entity_name, entity, organization), idmap: sub_entity_instance.create_idmap_from_external_entity(entity, connec_entity_name, organization)}
+            next {entity: sub_entity_instance.map_to(connec_entity_name, entity, organization), idmap: sub_entity_instance.class.create_idmap_from_external_entity(entity, connec_entity_name, organization)}
           end
 
           # Not pushing entity to Connec!
           next nil unless idmap.to_connec
 
           # Entity has not been modified since its last push to connec!
-          next nil if Maestrano::Connector::Rails::Entity.not_modified_since_last_push_to_connec(idmap, entity, sub_entity_instance, organization)
+          next nil if Maestrano::Connector::Rails::Entity.not_modified_since_last_push_to_connec?(idmap, entity, sub_entity_instance, organization)
 
           # Check for conflict with entities from connec!
           equivalent_connec_entities = modeled_connec_entities[connec_entity_name][external_entity_name] || []

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

@@ -8,143 +8,191 @@ module Maestrano::Connector::Rails::Concerns::Entity
     def entities_list
       raise "Not implemented"
     end
-  end
 
-  @@external_name = Maestrano::Connector::Rails::External.external_name
+    # ----------------------------------------------
+    #                 IdMap methods
+    # ----------------------------------------------
+    def names_hash
+      {
+        connec_entity: connec_entity_name.downcase,
+        external_entity: external_entity_name.downcase
+      }
+    end
+
+    def find_or_create_idmap(organization_and_id)
+      Maestrano::Connector::Rails::IdMap.find_or_create_by(names_hash.merge(organization_and_id))
+    end
+
+    # organization_and_id can be either:
+    # * {connec_id: 'id', organization_id: 'id'}
+    # * {external_id: 'id', organization_id: 'id'}
+    # Needs to include either connec_entity or external_entity for complex entities
+    def find_idmap(organization_and_id)
+      Maestrano::Connector::Rails::IdMap.find_by(names_hash.merge(organization_and_id))
+    end
+
+    def create_idmap_from_external_entity(entity, organization)
+      h = names_hash.merge({
+        external_id: id_from_external_entity_hash(entity),
+        name: object_name_from_external_entity_hash(entity),
+        organization_id: organization.id
+      })
+      Maestrano::Connector::Rails::IdMap.create(h)
+    end
+
+    def create_idmap_from_connec_entity(entity, organization)
+      h = names_hash.merge({
+        connec_id: entity['id'],
+        name: object_name_from_connec_entity_hash(entity),
+        organization_id: organization.id
+      })
+      Maestrano::Connector::Rails::IdMap.create(h)
+    end
+
+    # ----------------------------------------------
+    #              Connec! methods
+    # ----------------------------------------------
+    def normalized_connec_entity_name
+      normalize_connec_entity_name(connec_entity_name)
+    end
+
+    def normalize_connec_entity_name(name)
+      if singleton?
+        name.parameterize('_')
+      else
+        name.parameterize('_').pluralize
+      end
+    end
+
+    # ----------------------------------------------
+    #             External methods
+    # ----------------------------------------------
+    def id_from_external_entity_hash(entity)
+      raise "Not implemented"
+    end
+
+    def last_update_date_from_external_entity_hash(entity)
+      raise "Not implemented"
+    end
+
+    # ----------------------------------------------
+    #             Entity specific methods
+    # Those methods need to be define in each entity
+    # ----------------------------------------------
+    # Is this resource a singleton (in Connec!)?
+    def singleton?
+      false
+    end
+
+    # Entity name in Connec!
+    def connec_entity_name
+      raise "Not implemented"
+    end
+
+    # Entity name in external system
+    def external_entity_name
+      raise "Not implemented"
+    end
+
+    # Entity Mapper Class
+    def mapper_class
+      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"
+    end
+
+    # Return a string representing the object from an external entity hash
+    def object_name_from_external_entity_hash(entity)
+      raise "Not implemented"
+    end
+  end
 
   # ----------------------------------------------
   #                 Mapper methods
   # ----------------------------------------------
   # Map a Connec! entity to the external format
   def map_to_external(entity, organization)
-    mapper_class.normalize(entity)
+    self.class.mapper_class.normalize(entity)
   end
 
   # Map an external entity to Connec! format
   def map_to_connec(entity, organization)
-    mapper_class.denormalize(entity)
+    self.class.mapper_class.denormalize(entity)
   end
 
-  # ----------------------------------------------
-  #                 IdMap methods
-  # ----------------------------------------------
-  def names_hash
-    {
-      connec_entity: connec_entity_name.downcase,
-      external_entity: external_entity_name.downcase
-    }
-  end
-
-  def find_or_create_idmap(organization_and_id)
-    Maestrano::Connector::Rails::IdMap.find_or_create_by(names_hash.merge(organization_and_id))
-  end
-
-  # organization_and_id can be either:
-  # * {connec_id: 'id', organization_id: 'id'}
-  # * {external_id: 'id', organization_id: 'id'}
-  # Needs to include either connec_entity or external_entity for complex entities
-  def find_idmap(organization_and_id)
-    Maestrano::Connector::Rails::IdMap.find_by(names_hash.merge(organization_and_id))
-  end
-
-  def create_idmap_from_external_entity(entity, organization)
-    h = names_hash.merge({
-      external_id: get_id_from_external_entity_hash(entity),
-      name: object_name_from_external_entity_hash(entity),
-      organization_id: organization.id
-    })
-    Maestrano::Connector::Rails::IdMap.create(h)
-  end
-
-  def create_idmap_from_connec_entity(entity, organization)
-    h = names_hash.merge({
-      connec_id: entity['id'],
-      name: object_name_from_connec_entity_hash(entity),
-      organization_id: organization.id
-    })
-    Maestrano::Connector::Rails::IdMap.create(h)
-  end
   # ----------------------------------------------
   #                 Connec! methods
   # ----------------------------------------------
-  def normalized_connec_entity_name
-    normalize_connec_entity_name(connec_entity_name)
-  end
-
-  def normalize_connec_entity_name(connec_entity_name)
-    if singleton?
-      connec_entity_name.downcase
-    else
-      connec_entity_name.downcase.pluralize
-    end
-  end
-
   def get_connec_entities(client, last_synchronization, organization, opts={})
-    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Fetching Connec! #{connec_entity_name}")
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Fetching Connec! #{self.class.connec_entity_name}")
 
     entities = []
 
     # Fetch first page
     if last_synchronization.blank? || opts[:full_sync]
-      Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "entity=#{connec_entity_name}, fetching all data")
-      response = client.get("/#{normalized_connec_entity_name}")
+      Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "entity=#{self.class.connec_entity_name}, fetching all data")
+      response = client.get("/#{self.class.normalized_connec_entity_name}")
     else
-      Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "entity=#{connec_entity_name}, fetching data since #{last_synchronization.updated_at.iso8601}")
+      Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "entity=#{self.class.connec_entity_name}, fetching data since #{last_synchronization.updated_at.iso8601}")
       query_param = URI.encode("$filter=updated_at gt '#{last_synchronization.updated_at.iso8601}'")
-      response = client.get("/#{normalized_connec_entity_name}?#{query_param}")
+      response = client.get("/#{self.class.normalized_connec_entity_name}?#{query_param}")
     end
-    raise "No data received from Connec! when trying to fetch #{connec_entity_name.pluralize}" unless response
+    raise "No data received from Connec! when trying to fetch #{self.class.connec_entity_name.pluralize}" unless response
 
     response_hash = JSON.parse(response.body)
-    Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "received first page entity=#{connec_entity_name}, response=#{response.body}")
-    if response_hash["#{normalized_connec_entity_name}"]
-      entities << response_hash["#{normalized_connec_entity_name}"]
+    Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "received first page entity=#{self.class.connec_entity_name}, response=#{response.body}")
+    if response_hash["#{self.class.normalized_connec_entity_name}"]
+      entities << response_hash["#{self.class.normalized_connec_entity_name}"]
     else
-      raise "Received unrecognized Connec! data when trying to fetch #{connec_entity_name.pluralize}"
+      raise "Received unrecognized Connec! data when trying to fetch #{self.class.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(/^(.*)\/#{normalized_connec_entity_name}/, normalized_connec_entity_name)
+      next_page = response_hash['pagination']['next'].gsub(/^(.*)\/#{self.class.normalized_connec_entity_name}/, self.class.normalized_connec_entity_name)
       response = client.get(next_page)
 
-      raise "No data received from Connec! when trying to fetch subsequent page of #{connec_entity_name.pluralize}" unless response
-      Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "received next page entity=#{connec_entity_name}, response=#{response.body}")
+      raise "No data received from Connec! when trying to fetch subsequent page of #{self.class.connec_entity_name.pluralize}" unless response
+      Maestrano::Connector::Rails::ConnectorLogger.log('debug', organization, "received next page entity=#{self.class.connec_entity_name}, response=#{response.body}")
 
       response_hash = JSON.parse(response.body)
-      if response_hash["#{normalized_connec_entity_name}"]
-        entities << response_hash["#{normalized_connec_entity_name}"]
+      if response_hash["#{self.class.normalized_connec_entity_name}"]
+        entities << response_hash["#{self.class.normalized_connec_entity_name}"]
       else
-        raise "Received unrecognized Connec! data when trying to fetch subsequent page of #{connec_entity_name.pluralize}"
+        raise "Received unrecognized Connec! data when trying to fetch subsequent page of #{self.class.connec_entity_name.pluralize}"
       end
     end
 
     entities = entities.flatten
-    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Received data: Source=Connec!, Entity=#{connec_entity_name}, Data=#{entities}")
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Received data: Source=Connec!, Entity=#{self.class.connec_entity_name}, Data=#{entities}")
     entities
   end
 
   def push_entities_to_connec(connec_client, mapped_external_entities_with_idmaps, organization)
-    push_entities_to_connec_to(connec_client, mapped_external_entities_with_idmaps, connec_entity_name, organization)
+    push_entities_to_connec_to(connec_client, mapped_external_entities_with_idmaps, self.class.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} #{external_entity_name.pluralize} to Connec! #{connec_entity_name.pluralize}")
+    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}")
     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]
 
       begin
         if idmap.connec_id.blank?
-          connec_entity = create_connec_entity(connec_client, external_entity, normalize_connec_entity_name(connec_entity_name), organization)
-          idmap.update_attributes(connec_id: connec_entity['id'], connec_entity: connec_entity_name.downcase, last_push_to_connec: Time.now, message: nil)
+          connec_entity = create_connec_entity(connec_client, external_entity, self.class.normalize_connec_entity_name(connec_entity_name), organization)
+          idmap.update_attributes(connec_id: connec_entity['id'], last_push_to_connec: Time.now, message: nil)
         else
-          connec_entity = update_connec_entity(connec_client, external_entity, idmap.connec_id, normalize_connec_entity_name(connec_entity_name), organization)
+          connec_entity = update_connec_entity(connec_client, external_entity, idmap.connec_id, self.class.normalize_connec_entity_name(connec_entity_name), organization)
           idmap.update_attributes(last_push_to_connec: Time.now, message: nil)
         end
       rescue => e
         # Store Connec! error if any
+        Maestrano::Connector::Rails::ConnectorLogger.log('error', organization, "Error while pushing to Connec!: #{e}")
         idmap.update_attributes(message: e.message)
       end
     end
@@ -167,18 +215,18 @@ module Maestrano::Connector::Rails::Concerns::Entity
   end
 
   def map_to_external_with_idmap(entity, organization)
-    idmap = find_idmap({connec_id: entity['id'], organization_id: organization.id})
+    idmap = self.class.find_idmap({connec_id: entity['id'], organization_id: organization.id})
 
     if idmap
-      idmap.update(name: object_name_from_connec_entity_hash(entity))
+      idmap.update(name: self.class.object_name_from_connec_entity_hash(entity))
       if (!idmap.to_external) || (idmap.last_push_to_external && idmap.last_push_to_external > entity['updated_at'])
-        Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard Connec! #{connec_entity_name} : #{entity}")
+        Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard Connec! #{self.class.connec_entity_name} : #{entity}")
         nil
       else
         {entity: map_to_external(entity, organization), idmap: idmap}
       end
     else
-      {entity: map_to_external(entity, organization), idmap: create_idmap_from_connec_entity(entity, organization)}
+      {entity: map_to_external(entity, organization), idmap: self.class.create_idmap_from_connec_entity(entity, organization)}
     end
   end
 
@@ -186,16 +234,16 @@ module Maestrano::Connector::Rails::Concerns::Entity
   #                 External methods
   # ----------------------------------------------
   def get_external_entities(client, last_synchronization, organization, opts={})
-    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Fetching #{@@external_name} #{external_entity_name.pluralize}")
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Fetching #{Maestrano::Connector::Rails::External.external_name} #{self.class.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, external_entity_name, organization)
+    push_entities_to_external_to(external_client, mapped_connec_entities_with_idmaps, self.class.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! #{connec_entity_name.pluralize} to #{@@external_name} #{external_entity_name.pluralize}")
+    Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Sending Connec! #{self.class.connec_entity_name.pluralize} to #{Maestrano::Connector::Rails::External.external_name} #{external_entity_name.pluralize}")
     mapped_connec_entities_with_idmaps.each do |mapped_connec_entity_with_idmap|
       push_entity_to_external(external_client, mapped_connec_entity_with_idmap, external_entity_name, organization)
     end
@@ -208,35 +256,27 @@ module Maestrano::Connector::Rails::Concerns::Entity
     begin
       if idmap.external_id.blank?
         external_id = create_external_entity(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, message: nil)
+        idmap.update_attributes(external_id: external_id, last_push_to_external: Time.now, message: nil)
       else
         update_external_entity(external_client, connec_entity, idmap.external_id, external_entity_name, organization)
         idmap.update_attributes(last_push_to_external: Time.now, message: nil)
       end
     rescue => e
       # Store External error
+      Maestrano::Connector::Rails::ConnectorLogger.log('error', organization, "Error while pushing to #{Maestrano::Connector::Rails::External.external_name}: #{e}")
       idmap.update_attributes(message: e.message)
     end
   end
 
   def create_external_entity(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}")
+    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"
   end
 
   def update_external_entity(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}")
+    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"
   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
   # ----------------------------------------------
@@ -245,25 +285,25 @@ module Maestrano::Connector::Rails::Concerns::Entity
   # * Maps not discarded entities and associates them with their idmap, or create one if there isn't any
   # * Return a hash {connec_entities: [], external_entities: []}
   def consolidate_and_map_data(connec_entities, external_entities, organization, opts={})
-    return consolidate_and_map_singleton(connec_entities, external_entities, organization, opts) if singleton?
+    return consolidate_and_map_singleton(connec_entities, external_entities, organization, opts) if self.class.singleton?
 
     mapped_external_entities = external_entities.map{|entity|
-      idmap = find_idmap({external_id: get_id_from_external_entity_hash(entity), organization_id: organization.id})
+      idmap = self.class.find_idmap({external_id: self.class.id_from_external_entity_hash(entity), organization_id: organization.id})
       # No idmap: creating one, nothing else to do
       if idmap
-        idmap.update(name: object_name_from_external_entity_hash(entity))
+        idmap.update(name: self.class.object_name_from_external_entity_hash(entity))
       else
-        next {entity: map_to_connec(entity, organization), idmap: create_idmap_from_external_entity(entity, organization)}
+        next {entity: map_to_connec(entity, organization), idmap: self.class.create_idmap_from_external_entity(entity, organization)}
       end
 
       # Not pushing entity to Connec!
       next nil unless idmap.to_connec
 
       # Entity has not been modified since its last push to connec!
-      next nil if self.class.not_modified_since_last_push_to_connec(idmap, entity, self, organization)
+      next nil if self.class.not_modified_since_last_push_to_connec?(idmap, entity, self, organization)
 
       # Check for conflict with entities from connec!
-      self.class.solve_conflict(entity, self, connec_entities, connec_entity_name, idmap, organization, opts)
+      self.class.solve_conflict(entity, self, connec_entities, self.class.connec_entity_name, idmap, organization, opts)
     }
     mapped_external_entities.compact!
 
@@ -278,7 +318,7 @@ module Maestrano::Connector::Rails::Concerns::Entity
   def consolidate_and_map_singleton(connec_entities, external_entities, organization, opts={})
     return {connec_entities: [], external_entities: []} if external_entities.empty? && connec_entities.empty?
 
-    idmap = find_or_create_idmap({organization_id: organization.id})
+    idmap = self.class.find_or_create_idmap({organization_id: organization.id})
 
     if external_entities.empty?
       keep_external = false
@@ -290,61 +330,37 @@ module Maestrano::Connector::Rails::Concerns::Entity
       keep_external = self.class.is_external_more_recent?(connec_entities.first, external_entities.first, self)
     end
     if keep_external
-      idmap.update(external_id: get_id_from_external_entity_hash(external_entities.first), name: object_name_from_external_entity_hash(external_entities.first))
+      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))
       return {connec_entities: [], external_entities: [{entity: map_to_connec(external_entities.first, organization), idmap: idmap}]}
     else
-      idmap.update(connec_id: connec_entities.first['id'], name: object_name_from_connec_entity_hash(connec_entities.first))
+      idmap.update(connec_id: connec_entities.first['id'], name: self.class.object_name_from_connec_entity_hash(connec_entities.first))
       return {connec_entities: [{entity: map_to_external(connec_entities.first, organization), idmap: idmap}], external_entities: []}
     end
   end
 
   # ----------------------------------------------
-  #             Entity specific methods
-  # Those methods need to be define in each entity
+  #             After and before sync
   # ----------------------------------------------
-  # Is this resource a singleton (in Connec!)?
-  def singleton?
-    false
+  def before_sync(connec_client, external_client, organization)
+    # Does nothing by default
   end
 
-  # Entity name in Connec!
-  def connec_entity_name
-    raise "Not implemented"
+  def after_sync(connec_client, external_client, organization)
+    # Does nothing by default
   end
 
-  # Entity name in external system
-  def external_entity_name
-    raise "Not implemented"
-  end
-
-  # Entity Mapper Class
-  def mapper_class
-    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"
-  end
-
-  # Return a string representing the object from an external entity hash
-  def object_name_from_external_entity_hash(entity)
-    raise "Not implemented"
-  end
-
-
   # ----------------------------------------------
   #             Internal helper methods
   # ----------------------------------------------
   module ClassMethods
-    def not_modified_since_last_push_to_connec(idmap, entity, entity_instance, organization)
-      result = idmap.last_push_to_connec && idmap.last_push_to_connec > entity_instance.get_last_update_date_from_external_entity_hash(entity)
-      Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard #{entity_instance.external_entity_name} : #{entity}") if result
+    def not_modified_since_last_push_to_connec?(idmap, entity, entity_instance, organization)
+      result = idmap.last_push_to_connec && idmap.last_push_to_connec > entity_instance.class.last_update_date_from_external_entity_hash(entity)
+      Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Discard #{Maestrano::Connector::Rails::External::external_name} #{entity_instance.class.external_entity_name} : #{entity}") if result
       result
     end
 
     def is_external_more_recent?(connec_entity, external_entity, entity_instance)
-      connec_entity['updated_at'] < entity_instance.get_last_update_date_from_external_entity_hash(external_entity)
+      connec_entity['updated_at'] < entity_instance.class.last_update_date_from_external_entity_hash(external_entity)
     end
 
     def solve_conflict(external_entity, entity_instance, connec_entities, connec_entity_name, idmap, organization, opts)
@@ -357,11 +373,11 @@ module Maestrano::Connector::Rails::Concerns::Entity
         end
 
         if keep_external
-          Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Conflict between #{entity_instance.external_entity_name} #{external_entity} and Connec! #{connec_entity_name} #{connec_entity}. Entity from external kept")
+          Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Conflict between #{Maestrano::Connector::Rails::External::external_name} #{entity_instance.class.external_entity_name} #{external_entity} and Connec! #{connec_entity_name} #{connec_entity}. Entity from external kept")
           connec_entities.delete(connec_entity)
           entity_instance.map_external_entity_with_idmap(external_entity, connec_entity_name, idmap, organization)
         else
-          Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Conflict between #{entity_instance.external_entity_name} #{external_entity} and Connec! #{connec_entity_name} #{connec_entity}. Entity from Connec! kept")
+          Maestrano::Connector::Rails::ConnectorLogger.log('info', organization, "Conflict between #{Maestrano::Connector::Rails::External::external_name} #{entity_instance.class.external_entity_name} #{external_entity} and Connec! #{connec_entity_name} #{connec_entity}. Entity from Connec! kept")
           nil
         end