eco-helpers 1.4.0 → 1.5.2

data/lib/eco/api/usecases/default_cases/set_supervisor_case.rb

@@ -1,41 +1,23 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class SetSupervisorCase < DefaultCase
+class Eco::API::UseCases::DefaultCases::SetSupervisorCase < Eco::API::Common::Loaders::UseCase
+  name "set-supervisor"
+  type :sync
 
-          def process
-            @cases.define("set-supervisor", type: :sync) do |entries, people, session, options, usecase|
-              job = session.job_group("main").new("update", usecase: usecase, type: :update, sets: :core)
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    update   = session.new_job("main", "update", :update, usecase)
 
-              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-
-              entries.each.with_index do |entry, i|
-                person = people.find(entry, strict: strict_search)
-
-                if !person
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{entry.to_s(:identify)}")
-                else
-                  sup_id = entry.supervisor_id
-                  supervisor = people.person(id: sup_id, external_id: sup_id, email: sup_id)
-
-                  if !supervisor
-                    if entry.supervisor_id
-                      msg = "Entry(#{i}) - supervisor id #{entry.supervisor_id} does not exist for person: #{entry.to_s(:identify)}"
-                      session.logger.warn(msg)
-                    end
-                  else
-                    # set internal id of the supervisor (detect if actually changed)
-                    person.supervisor_id = supervisor.id
-                    job.add(person)
-                  end
-                end
-              end
-            end
+    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
+      micro.with_supervisor(entry.supervisor_id, people) do |supervisor|
+        if supervisor
+          update.add(person)
+          person.supervisor_id = supervisor.id unless options.dig(:exclude, :supervisor)
+        else
+          unless !entry.supervisor_id
+            session.logger.warn("Supervisor '#{entry.supervisor_id}' does not exist. Entry: #{entry.to_s(:identify)}")
           end
-
         end
       end
     end
   end
+
 end

data/lib/eco/api/usecases/default_cases/switch_supervisor_case.rb

@@ -1,61 +1,70 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class SwitchSupervisorCase < DefaultCase
-
-          def process
-            @cases.define("switch-supervisor", type: :transform) do |people, session, options, usecase|
-
-              unless old_id = options.dig(:super, :old)
-                msg = "You haven't specified the original supervisor. Aborting..."
-                session.logger.error(msg)
-                exit(1)
-              end
-
-              # we could be setting the supervisor to nil
-              unless options[:super].key?(:new)
-                msg = "You haven't specified the new supervisor. Aborting..."
-                session.logger.error(msg)
-                exit(1)
-              end
-
-              new_id =  options.dig(:super, :new)
-
-              unless old_sup = people.person(id: old_id, external_id: old_id, email: old_id)
-                msg = "Couldn't find any user with that id (old-super): '#{old_id}'. Aborting..."
-                session.logger.error(msg)
-                exit(1)
-              end
-
-              unless new_sup = people.person(id: new_id, external_id: new_id, email: new_id)
-                msg = "Couldn't find any user with that id (new-super): '#{new_id}'. Aborting..."
-                session.logger.error(msg)
-                exit(1)
-              end
-
-              people = people.supervisor_id(old_sup.id)
-              unless people.length > 0
-                msg = "There are no people with supervisor #{old_sup.external_id} (#{old_sup.name} - #{old_sup.email}). Aborting..."
-                session.logger.error(msg)
-                exit(1)
-              end
-
-              session.logger.info("Going to change supervisor '#{old_sup.name}' (#{old_sup.external_id}) to '#{new_sup.name}' (#{new_sup.external_id})")
-
-              # create batch queue
-              supers = session.job_group("main").new("update", usecase: usecase, type: :update, sets: :core)
-
-              people.each.with_index do |person, i|
-                person.supervisor_id = new_sup.id
-                supers.add(person)
-              end
-
-            end
-          end
-
-        end
+class Eco::API::UseCases::DefaultCases::SwitchSupervisorCase < Eco::API::Common::Loaders::UseCase
+  name "switch-supervisor"
+  type :transform
+
+  def main(people, session, options, usecase)
+    micro    = session.micro
+    supers   = session.new_job("main", "supers", :update, usecase, :core)
+
+    old_sup, new_sup = get_supers(people, session, options).tap do |supers|
+      inform(*supers, session.logger)
+    end
+
+    micro.with_each_subordinate(old_sup, people) do |subordinate|
+      subordinate.supervisor_id = new_sup&.id
+      supers.add(subordinate)
+    end.tap do |subordinates|
+      unless subordinates.length > 0
+        sup_str = "#{old_sup.external_id} (#{old_sup.name} - #{old_sup.email})"
+        session.logger.error("There are no subordinates for supervisor #{sup_str}. Aborting...")
+        exit(1)
       end
     end
   end
+
+  private
+
+  def get_supers(people, session, options)
+    micro            = session.micro
+    old_id,  new_id  = get_super_ids(options)
+    old_sup, new_sup = [nil, nil]
+
+    micro.with_supervisor(old_id, people) do |supervisor|
+      unless old_sup = supervisor
+        session.logger.error("Couldn't find any user with that id (old-super): '#{old_id}'. Aborting...")
+        exit(1)
+      end
+    end
+
+    micro.with_supervisor(new_id, people) do |supervisor|
+      unless new_sup = supervisor
+        session.logger.error("Couldn't find any user with that id (new-super): '#{new_id}'. Aborting...")
+        exit(1)
+      end
+    end
+
+    [old_sup, new_sup]
+  end
+
+  def get_super_ids(options)
+    unless old_id = options.dig(:super, :old)
+      session.logger.error("You haven't specified the original supervisor. Aborting...")
+      exit(1)
+    end
+
+    # we could be setting the supervisor to nil
+    unless options[:super].key?(:new)
+      session.logger.error("You haven't specified the new supervisor. Aborting...")
+      exit(1)
+    end
+
+    [old_id, options.dig(:super, :new)]
+  end
+
+  def inform(old_sup, new_sup, logger)
+    msg  = "Switching supervisor '#{old_sup.name}' (#{old_sup.external_id}) "
+    msg += "to '#{new_sup&.name}' (#{new_sup&.external_id})"
+    logger.info(msg)
+  end
+
 end

data/lib/eco/api/usecases/default_cases/to_csv_case.rb

@@ -1,53 +1,45 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class ToCsvCase < DefaultCase
+class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::UseCase
+  name "to-csv"
+  type :export
 
-          def process
-            @cases.define("to-csv", type: :export) do |people, session, options, usecase|
-              unless people && !people.empty?
-                session.logger.warn("No source people to create the file... aborting!")
-                next false
-              end
-
-              unless file = options[:file] || options.dig(:export, :file, :name)
-                session.logger.error("Destination file not specified")
-                next false
-              end
+  def main(people, session, options, usecase)
+    unless people && !people.empty?
+      session.logger.warn("No source people to create the file... aborting!")
+      return false
+    end
 
-              session.logger.info("going to create file: #{file}")
-              CSV.open(file, "w") do |csv|
-                deps   = {"supervisor_id" => {people: people}}
-                entry  = session.new_entry(people.first, dependencies: deps)
-                header = entry.to_hash.keys
+    unless file = options[:file] || options.dig(:export, :file, :name)
+      session.logger.error("Destination file not specified")
+      return false
+    end
 
-                if options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
-                  name_maps = session.schema.fields_by_alt_id.transform_values do |fld|
-                    fld.name
-                  end.merge({
-                    "policy_group_ids" => "User Group(s)",
-                    "email" => "Email",
-                    "name" => "Name",
-                    "supervisor_id" => "Manager ID",
-                    "filter_tags" => "Locations",
-                    "default_tag" => "Default Location",
-                    "id" => "ecoPortal ID"
-                  })
-                  header = header.map {|name| name_maps[name] ? name_maps[name] : name}
-                end
+    session.logger.info("going to create file: #{file}")
+    CSV.open(file, "w") do |csv|
+      deps   = {"supervisor_id" => {people: people}}
+      entry  = session.new_entry(people.first, dependencies: deps)
+      header = entry.external_entry.keys
 
-                csv << header
-                people.each do |person|
-                  csv << session.new_entry(person, dependencies: deps).to_hash.values
-                end
-              end
-              exit(0)
-            end
-          end
+      if options.dig(:nice_header) || options.dig(:export, :options, :nice_header)
+        name_maps = session.schema.fields_by_alt_id.transform_values do |fld|
+          fld.name
+        end.merge({
+          "policy_group_ids" => "User Group(s)",
+          "email"            => "Email",
+          "name"             => "Name",
+          "supervisor_id"    => "Manager ID",
+          "filter_tags"      => "Locations",
+          "default_tag"      => "Default Location",
+          "id"               => "ecoPortal ID"
+        })
+        header = header.map {|name| name_maps[name] ? name_maps[name] : name}
+      end
 
-        end
+      csv << header
+      people.each do |person|
+        csv << session.new_entry(person, dependencies: deps).external_entry.values
       end
     end
+    exit(0)
   end
+
 end

data/lib/eco/api/usecases/default_cases/to_csv_detailed_case.rb

@@ -1,68 +1,53 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class ToCsvDetailedCase < DefaultCase
-
-          def process
-            @cases.define("to-csv-detailed", type: :export) do |people, session, options, usecase|
-              unless people && !people.empty?
-                session.logger.warn("No source people to create the file... aborting!")
-                next false
-              end
-
-              unless file = options[:file] || options.dig(:export, :file, :name)
-                session.logger.error("Destination file not specified")
-                next false
-              end
-
-              login_providers = session.login_providers
-
-              abilities = session.new_preset([]).keys
+class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::Common::Loaders::UseCase
+  name "to-csv-detailed"
+  type :export
+
+  def main(people, session, options, usecase)
+    unless people && !people.empty?
+      session.logger.warn("No source people to create the file... aborting!")
+      return false
+    end
 
-              session.logger.info("going to create file: #{file}")
-              CSV.open(file, "w") do |csv|
-                deps    = {"supervisor_id" => {people: people}}
-                header  = session.new_entry(people.first, dependencies: deps).to_hash.keys
-                header += ["Subordinates"]
-                header += ["Supervisor Name"]
-                header += abilities
-                header += ["Login Methods"] if login_providers.any_optional?
-                header += ["Landing Page"]
+    unless file = options[:file] || options.dig(:export, :file, :name)
+      session.logger.error("Destination file not specified")
+      return false
+    end
 
-                csv << header
-                people.each do |person|
-                  data = session.new_entry(person, dependencies: deps).to_hash.values
+    login_providers = session.login_providers
+    abilities       = session.presets_factory.keys
 
-                  data.push(person.subordinates)
-                  super_id = person.supervisor_id
-                  if supervisor = people.person(id: super_id, external_id: super_id)
-                    data.push(supervisor.name)
-                  else
-                    data.push("")
-                  end
+    session.logger.info("going to create file: #{file}")
+    CSV.open(file, "w") do |csv|
+      deps    = {"supervisor_id" => {people: people}}
 
-                  person_abilities = (person.account && person.account.permissions_custom) || {}
-                  data += abilities.map {|key| person_abilities[key] || "no access"}
+      person_model = people.first
+      person_entry = session.new_entry(person_model, dependencies: deps)
+      header  = person_entry.external_entry.keys
+      header += ["Subordinates"]
+      header += ["Supervisor Name"]
+      header += abilities
+      header += ["Landing Page"]
 
-                  if login_providers.any_optional?
-                    logins = (person.account && person.account.login_provider_ids) || []
-                    data.push(login_providers.to_name(logins).join("|"))
-                  end
+      csv << header
+      people.each do |person|
+        data = session.new_entry(person, dependencies: deps).external_entry.values
 
-                  if person.account && landing_id = person.account.landing_page_id
-                    data.push(landing_id)
-                  end
+        data.push(person.subordinates)
+        session.micro.with_supervisor(person.supervisor_id, people) do |supervisor|
+          data.push supervisor ? supervisor.name : ""
+        end
 
-                  csv << data
-                end
-              end
-              exit(0)
-            end
-          end
+        person_abilities = (person.account && person.account.permissions_custom) || {}
+        data += abilities.map {|key| person_abilities[key] || "no access"}
 
+        if person.account && landing_id = person.account.landing_page_id
+          data.push(landing_id)
         end
+
+        csv << data
       end
     end
+    exit(0)
   end
+
 end

data/lib/eco/api/usecases/default_cases/transfer_account_case.rb

@@ -1,90 +1,270 @@
-module Eco
-  module API
-    class UseCases
-      class DefaultCases
-        class TransferAccountCase < DefaultCase
-
-          def process
-            @cases.define("transfer-account", type: :sync) do |entries, people, session, options, usecase|
-              remove_account = session.job_group("main").new("remove account", usecase: usecase, type: :update, sets: :account)
-              add_account    = session.job_group("post").new("add account", usecase: usecase, type: :update, sets: :account)
-
-              strict_search = session.config.people.strict_search? && (!options[:search]&.key?(:strict) || options.dig(:search, :strict))
-
-              done = []; pending = []
-              pairs = entries.each_with_object([]) do |source|
-                entry_hash = source.internal_entry
-                unless entry_hash.key?("destination-id")
-                  session.logger.error("You haven't defined a column 'destination-id' to whom the account should be transferred")
-                  exit(1)
-                end
-                if peer_id = entry_hash["destination-id"]
-                  if peer = entries.entry(id: peer_id, external_id: peer_id)
-                    if done.include?(peer)
-                      session.logger.error("You paired '#{peer_id}' twice. A person can only receive account from 1 user")
-                      exit(1)
-                    end
-                    pending.delete(source)
-                    pending.delete(peer)
-                    done.push(source).push(pair)
-                    [source, peer]
-                  else
-                    pending.push(source)
-                    nil
-                  end
-                else
-                  pending.push(source)
-                end
-              end.compact
-
-              # Data input integrity check
-              unless pending.empty?
-                msg  = "You haven't defined a pair for the following ids:"
-                msg += pending.each_with_object("") do |entry, str|
-                  str << "\n#{entry.id || entry.external_id}"
-                end
-                session.logger.error(msg)
-                exit(1)
-              end
-
-              pairs.each do |pair|
-                src_entry, dst_entry = pair
-                unless src_person = people.find(src_entry, strict: strict_search)
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{src_entry.to_s(:identify)}")
-                  exit(1)
-                end
-
-                unless dst_person = people.find(dst_entry,  strict: strict_search)
-                  session.logger.error("Entry(#{i}) - this person does not exist: #{dst_person.to_s(:identify)}")
-                  exit(1)
-                end
-
-                unless account_doc = src_person.account&.doc
-                  session.logger.error("You are trying to move account from a person that doesn't have: #{src_person.id | src_person.external_id}")
-                  exit(1)
-                end
-
-                if dst_person.email.to_s.strip.empty?
-                  session.logger.error("A person you are trying to add account doesn't have email: #{dst_person.id | dst_person.external_id}")
-                  exit(1)
-                end
-
-                src_person.account = nil
-                remove_account.add(src_person)
-                add_account.add(dst_person) do |person|
-                  # only if we got to remove the account of the original person
-                  if account_doc && src_person.as_update == {}
-                    person.account = account_doc
-                  end
-                end
-
-              end
-
-            end
-          end
+class Eco::API::UseCases::DefaultCases::TransferAccountCase < Eco::API::Common::Loaders::UseCase
+  name "transfer-account"
+  type :sync
 
+  # Usecase to **actually transfer a user/account** from one person to another person in the organization.
+  #   * **invocation command**: `-transfer-account-from`
+  #
+  # These are the steps and jobs it does:
+  #   1. **pair** person entries (note: the `destination-id` entry could not be present, it will add it in such a case).
+  #   2. **retrieve** from server persons that were not included in `people`.
+  #   3. **validation**
+  #     - a person should only receive account from just one user
+  #     - a person should only give account to just one user
+  #     - every account giver should have account
+  #   4. **create jobs**
+  #     - **move** giver's and receiver's **accounts** to dummy email addresses.
+  #       * dummy email pattern: from name@domain.ltd --to--> demo+name.domain.ltd@ecoportal.co.nz
+  #     - **free up** giver's and receiver's **accounts**.
+  #     - **switch** email: set receiver's email to that of giver's dummy address.
+  #       * to ensure account transfer, as we moved accounts to dummy emails, those dummy addresses should be used
+  #     - **invite** receivers: adds account to the destination person in the dummy email.
+  #       * actual user/account transfer to the person/receiver
+  #       * **no notification** will be recived by the user, because of the dummy address at this stage
+  #     - **restore** email: sets the receiver email from the dummy address to the final email.
+  #       * the final email inbox will receive a **notification** of _email change_
+  # @note
+  #   - the `csv` should contain a column `destination-id` containing the person `id` or `external_id` of the person that will be receiving the account.
+  #   - when running this case, it is recommended to use the option `-skip-batch-policies`
+  #   - it is highly recommended to either refresh the cache with `-get-people` or use the `-get-partial` option.
+  # @param entries [Eco::API::Common::People::Entries] the input entries with the data.
+  # @param people [Eco::API::Organization::People] target existing _People_ of the current update.
+  # @param session [Eco::API::Session] the current session where the usecase kicks in.
+  # @param options [Hash] the options that modify the case behaviour or bring some dependencies.
+  # @option options [Hash<Symbol, Object>] :include things that should be included.
+  #   * `:email` (Boolean) [false] if the `email` should be transferred as well (**command option**: `-include-email`)
+  # @option options [Hash<Symbol, Object>] :skip things that should be excluded.
+  #   * `:api_policies` (Boolean) [false] if the `api policies` should be skipped (**command option**: `-skip-api-policies`)
+  # @return [Void]
+  def main(entries, people, session, options, usecase)
+    micro    = session.micro
+    move     = session.new_job("main", "move email accounts", :update, usecase, :account)
+    free     = session.new_job("main", "free up accounts",    :update, usecase, :account)
+    switch   = session.new_job("main", "switch email",        :update, usecase, :core)
+    invite   = session.new_job("post", "invite receivers",    :update, usecase, :account)
+    restore  = session.new_job("post", "restore email",       :update, usecase, :core)
+
+    with_each_person_pair(entries, people, session, options) do |src_person, dst_person|
+      # capture actual initial information
+      src_doc   = src_person.account.doc
+      src_email = src_person.email
+      src_dummy = dummy_email(src_person)
+      dst_email = dst_person.email
+      dst_dummy = dummy_email(dst_person)
+      copy_src_email  = options.dig(:include, :email) || !dst_person.account
+      dst_end_email   = copy_src_email ? src_email : dst_email
+
+      # account email renamings are necessary to avoid uncertainty and ensure no email taken error
+      move.add(dst_person)    {|dst| dst.email = dst_dummy}
+      move.add(src_person)    {|src| src.email = src_dummy}
+      # free accounts up!
+      free.add([dst_person, src_person]) {|person| person.account = nil}
+      # to effectivelly transfer the user/account, email should be the same during invite
+      # otherwise the account doesn't actually get transferred but just copied
+      switch.add(dst_person)  {|dst| dst.email = src_dummy}
+      # do the actual transfer of account
+      invite.add(dst_person)  {|dst| dst.account = src_doc}
+      # recover the original email, if the receiver had account
+      restore.add(dst_person) {|dst| dst.email = dst_end_email}
+    end.tap do |units|
+      if options[:simulate]
+        units.each {|unit| puts unit.persons.map(&:external_id).join(" --> ")}
+      end
+    end
+  end
+
+  private
+
+  # if the person has account and an email different to demo+__@ecoportal.co.nz
+  # it transforms email to demo+__@ecoportal.co.nz
+  def dummy_email(person)
+    return nil   unless email = person.email
+    return email if email.start_with?("demo") && email.end_with?("@ecoportal.co.nz")
+    return email unless person.account
+    "demo+#{email.split("@").join(".")}@ecoportal.co.nz"
+  end
+
+  def with_each_person_pair(entries, people, session, options)
+    units = paired_entries(entries, session) do |unpaired_entries|
+      report_missing_peer!(unpaired_entries, session.logger)
+    end.map do |entry_pair|
+      person_pair = to_persons(entry_pair, people, session, options)
+      new_unit(*entry_pair, *person_pair)
+    end
+    sort_units(units).tap do |units|
+      # check that there are no repeated sources or destinations, that sources have account
+      validate_pairs!(units, session.logger)
+      units.each do |unit|
+        yield(*unit.persons) if block_given?
+      end
+    end
+  end
+
+  # account givers that are receivers should give first
+  # exchangers are placed at the beginning
+  def sort_units(units)
+    base       = units.dup
+    # cases where two persons exchange account
+    exchangers = base.select do |source|
+      base.any? {|dest| source.reversed_unit?(dest)}
+    end
+    exchangers | base.sort
+  end
+
+  # Entry helpers
+  def to_persons(paired_entry, people, session, options)
+    micro    = session.micro
+    [].tap do |persons|
+      micro.with_each(paired_entry, people, options) do |entry, person|
+        next persons.push(person) unless person.new?
+        if person = session.batch.search([entry], silent: true).people.first
+          persons.push(person)
+          people << person
+          next
         end
+        session.logger.error("This person does not exist: #{entry.to_s(:identify)}")
+        exit(1)
+      end
+    end.tap do |persons|
+      yield(*persons) if block_given?
+    end
+  end
+
+  def paired_entries(entries, session)
+    expect_destination_id!(entries, session.logger)
+    missing_peer = []
+    entries.each_with_object([]) do |source, out|
+      if peer = entry_peer(source, entries)
+        out.push([source, peer])
+      else
+        missing_peer.push(source)
+      end
+    end.tap do |paired_entries|
+      yield(missing_peer) if block_given?
+    end
+  end
+
+  def entry_peer(entry, entries)
+    return nil unless peer_id = entry_peer_id(entry)
+    entries.entry(id: peer_id, external_id: peer_id) || decouple_peer(entry)
+  end
+
+  def decouple_peer(entry)
+    entry.new({
+      "id"          => entry_peer_id(entry),
+      "external_id" => entry_peer_id(entry),
+      "email"       => entry_peer_id(entry),
+      "idx"         => entry.idx
+    })
+  end
+
+  def entry_peer_id(entry)
+    dest_id = entry.final_entry["destination-id"]
+    return dest_id unless dest_id.to_s.strip.empty?
+  end
+
+  def entry_peer_id?(entry)
+    entry.final_entry.key?("destination-id")
+  end
+
+  # Unit type helpers
+  def unit_type
+    @unit_type ||= Struct.new(:src_entry, :dst_entry, :src_person, :dst_person) do
+      def persons
+        [src_person, dst_person]
       end
+      def reversed_unit?(u2)
+        (src_person == u2.dst_person) && (dst_person == u2.src_person)
+      end
+      # givers go first
+      def <=>(other)
+        return -1 if src_person == other.dst_person
+        return  1 if dst_person == other.src_person
+        0
+      end
+    end
+  end
+
+  def new_unit(e1, e2, p1, p2)
+    unit_type.new(e1, e2, p1, p2)
+  end
+
+  # Units helpers
+  def find_repeated(units, &block)
+    units.group_by(&block).select do |k,v|
+      v.count > 1
+    end.map {|k, v| v.first}
+  end
+
+  def uniq_array(ary, &block)
+    ary.each_with_object([]) do |e, uniq|
+      uniq.push(e) unless uniq.any? {|chosen| block.call(chosen, e)}
+    end
+  end
+
+  def validate_pairs!(units, logger)
+    missing_account = []
+    src_repeated = find_repeated(units) do |unit|
+      unit.src_person.tap do |src_person|
+        missing_account << (src_person.account ? nil : str_person_entry(unit.src_person, unit.src_entry))
+      end
+    end.each_with_object([]) do |unit, lines|
+      lines << str_person_entry(unit.src_person, unit.src_entry)
+    end
+    dst_repeated = find_repeated(units) do
+      |unit| unit.dst_person
+    end.each_with_object([]) do |unit, lines|
+      lines << str_person_entry(unit.dst_person, unit.dst_entry, unit.src_entry.idx)
+    end
+    missing_account.compact!
+    unless [missing_account, src_repeated, dst_repeated].all?(&:empty?)
+      report_missing_account(missing_account.join("\n"), logger) unless missing_account.empty?
+
+      msg = Proc.new do |spot|
+        "Transfers should be a 1.to.1 relation. The following #{spot} entries are repeated in the csv:"
+      end
+      report_repeated(src_repeated.join("\n"), logger, msg["SOURCE"])       unless src_repeated.empty?
+      report_repeated(dst_repeated.join("\n"), logger, msg["DESTINATION"])  unless dst_repeated.empty?
+      exit(1)
     end
   end
+
+  # Messaging & Validation
+  def report_missing_peer!(unpaired_entries, logger)
+    unless unpaired_entries.empty?
+      msg  = "The following rows are missing 'destination-id':\n\n"
+      msg += unpaired_entries.map {|entry| str_missing_peer(entry)}.join("\n")
+      logger.error(msg)
+      exit(1)
+    end
+  end
+
+  def str_missing_peer(entry)
+    "Source #{entry.to_s(:identify)} is missing 'destination-id'."
+  end
+
+  def str_person_entry(person, entry, row = nil)
+    str_row = row ? "(actual row: #{row}) " : nil
+    "#{str_row}id: '#{person.id || person.external_id}' email:#{person.email} -> Entry #{entry.to_s(:identify)}"
+  end
+
+  def expect_destination_id!(entries, logger)
+    unless entries.length > 0
+      logger.error("Your csv is empty")
+      exit(1)
+    end
+    unless entry_peer_id?(entries.first)
+      logger.error("You haven't defined a column 'destination-id' to whom the account should be transferred")
+      exit(1)
+    end
+  end
+
+  def report_missing_account(str, logger)
+    logger.error("The following source people do not have account:\n#{str}")
+  end
+
+  def report_repeated(str, logger, msg = "The following entries are repeated")
+    logger.error("#{msg}\n#{str}")
+  end
+
 end