intercom_export 0.0.1

data/lib/intercom_export/listener/std.rb

@@ -0,0 +1,19 @@
+module IntercomExport
+  module Listener
+    class Std
+      def initialize(stdout: STDOUT, stderr: STDERR)
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def executing(command)
+        puts "Importing: #{command.inspect}"
+        puts
+      end
+
+      private
+
+      attr_reader :stdout, :stderr
+    end
+  end
+end

data/lib/intercom_export/model/intercom_admin.rb

@@ -0,0 +1,21 @@
+require 'intercom_export/reference'
+
+require 'virtus'
+
+module IntercomExport
+  module Model
+    class IntercomAdmin
+      include Virtus.value_object
+
+      values do
+        attribute :id, Integer
+        attribute :name, String
+        attribute :email, String
+      end
+
+      def reference
+        IntercomExport::Reference.new("intercom-admin-#{id}")
+      end
+    end
+  end
+end

data/lib/intercom_export/model/intercom_conversation.rb

@@ -0,0 +1,28 @@
+require 'intercom_export/reference'
+
+require 'virtus'
+
+module IntercomExport
+  module Model
+    class IntercomConversation
+      include Virtus.value_object
+
+      values do
+        attribute :id, String
+        attribute :name, String
+        attribute :user
+        attribute :assignee
+        attribute :conversation_message, Hash[Symbol => Object]
+        attribute :created_at
+        attribute :updated_at
+        attribute :tags
+        attribute :open
+        attribute :conversation_parts, Array[Hash[Symbol => Object]]
+      end
+
+      def reference
+        IntercomExport::Reference.new("intercom-conversation-#{id}")
+      end
+    end
+  end
+end

data/lib/intercom_export/model/intercom_user.rb

@@ -0,0 +1,21 @@
+require 'intercom_export/reference'
+
+require 'virtus'
+
+module IntercomExport
+  module Model
+    class IntercomUser
+      include Virtus.value_object
+
+      values do
+        attribute :id, String
+        attribute :name, String
+        attribute :email, String
+      end
+
+      def reference
+        IntercomExport::Reference.new("intercom-user-#{id}")
+      end
+    end
+  end
+end

data/lib/intercom_export/model/zendesk_ticket.rb

@@ -0,0 +1,42 @@
+require 'virtus'
+
+module IntercomExport
+  module Model
+    class ZendeskTicket
+      include Virtus.value_object
+
+      values do
+        attribute :id, Integer
+        attribute :url, String
+        attribute :external_id, String
+        attribute :type, String
+        attribute :subject, String
+        attribute :raw_subject, String
+        attribute :description, String
+        attribute :priority, String
+        attribute :status, String
+        attribute :recipient, String
+        attribute :requester_id, Integer
+        attribute :submitter_id, Integer
+        attribute :assignee_id, Integer
+        attribute :organization_id, Integer
+        attribute :group_id, Integer
+        attribute :collaborator_ids, Array
+        attribute :forum_topic_id, Integer
+        attribute :problem_id, Integer
+        attribute :has_incidents, Boolean
+        attribute :due_at, Time
+        attribute :tags, Array
+        attribute :via
+        attribute :custom_fields, Array
+        attribute :satisfaction_rating
+        attribute :sharing_agreement_ids, Array
+        attribute :followup_ids, Array
+        attribute :ticket_form_id, Integer
+        attribute :brand_id, Integer
+        attribute :created_at, Time
+        attribute :updated_at, Time
+      end
+    end
+  end
+end

data/lib/intercom_export/model/zendesk_user.rb

@@ -0,0 +1,45 @@
+require 'intercom_export/reference'
+require 'virtus'
+module IntercomExport
+  module Model
+    class ZendeskUser
+      include Virtus.value_object
+
+      values do
+        attribute :id, Integer
+        attribute :url, String
+        attribute :name, String
+        attribute :email, String
+        attribute :created_at, Time
+        attribute :updated_at, Time
+        attribute :time_zone, String
+        attribute :phone
+        attribute :photo
+        attribute :locale_id, Integer
+        attribute :locale, String
+        attribute :organization_id
+        attribute :role, String
+        attribute :verified, Boolean
+        attribute :external_id
+        attribute :tags, Array[String]
+        attribute :alias, String
+        attribute :active, Boolean
+        attribute :shared, Boolean
+        attribute :shared_agent, Boolean
+        attribute :last_login_at, Time
+        attribute :two_factor_auth_enabled
+        attribute :signature, String
+        attribute :details, String
+        attribute :notes, String
+        attribute :custom_role_id
+        attribute :moderator, Boolean
+        attribute :ticket_restriction
+        attribute :only_private_comments, Boolean
+        attribute :restricted_agent, Boolean
+        attribute :suspended, Boolean
+        attribute :chat_only, Boolean
+        attribute :user_fields, Hash
+      end
+    end
+  end
+end

data/lib/intercom_export/reference.rb

@@ -0,0 +1,18 @@
+module IntercomExport
+  class Reference
+    def initialize(value)
+      @value = value
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && value == other.value
+    end
+    alias_method :eql?, :==
+
+    def hash
+      self.value.hash
+    end
+
+    attr_reader :value
+  end
+end

data/lib/intercom_export/source/intercom_conversations.rb

@@ -0,0 +1,19 @@
+module IntercomExport
+  module Source
+    class IntercomConversations
+      def initialize(client)
+        @client = client
+      end
+
+      include Enumerable
+
+      def each(&block)
+        client.conversations.find_all({}).lazy.map { |c| client.conversations.find(id: c.id) }.each(&block)
+      end
+
+      private
+
+      attr_reader :client
+    end
+  end
+end

data/lib/intercom_export/splitter/intercom.rb

@@ -0,0 +1,81 @@
+require 'intercom_export/reference'
+require 'intercom_export/model/intercom_conversation'
+require 'intercom_export/model/intercom_user'
+require 'intercom_export/model/intercom_admin'
+
+module IntercomExport
+  module Splitter
+    class Intercom
+      def initialize(client)
+        @client = client
+      end
+
+      def split(conversation)
+        conversation_hash = flatten(conversation)
+
+        dependencies_for_conversation!(conversation_hash) + [
+          IntercomExport::Model::IntercomConversation.new(conversation_hash)
+        ]
+      end
+
+      private
+
+      attr_reader :client
+
+      def flatten(conversation)
+        hash = conversation.to_hash
+        hash['conversation_parts'] = hash.fetch('conversation_parts').map { |p| p.to_hash }
+        hash['conversation_message'] = hash.fetch('conversation_message').to_hash
+        hash
+      end
+
+      def model_for(object)
+        case object
+        when ::Intercom::User
+          load_user(object)
+        when ::Intercom::Admin
+          load_admin(object)
+        when ::Intercom::NobodyAdmin
+          nil
+        else
+          raise "Unrecognised object #{object.inspect}"
+        end
+      end
+
+      def load_user(object)
+        IntercomExport::Model::IntercomUser.new(client.users.find(id: object.id).to_hash)
+      end
+
+      def load_admin(object)
+        admin = client.admins.all.find { |a| a.id == Integer(object.id) }
+        return unless admin
+        IntercomExport::Model::IntercomAdmin.new(admin.to_hash)
+      end
+
+      def replace_reference!(hash, key)
+        value = hash[key]
+        return nil unless value
+        model = model_for(value)
+        hash[key] = model && model.reference
+        model
+      end
+
+      def dependencies_for_conversation!(conversation_hash)
+        dependencies = []
+
+        conversation_hash['conversation_parts'] = conversation_hash.fetch('conversation_parts').select { |p|
+          p.fetch('body', nil)
+        }.map { |part|
+          dependencies.push(replace_reference!(part, 'assigned_to'))
+          dependencies.push(replace_reference!(part, 'author'))
+          part
+        }
+
+        dependencies.push(replace_reference!(conversation_hash, 'user'))
+        dependencies.push(replace_reference!(conversation_hash, 'assignee'))
+        dependencies.push(replace_reference!(conversation_hash.fetch('conversation_message'), 'author'))
+        dependencies.compact.uniq
+      end
+    end
+  end
+end

data/lib/intercom_export/version.rb

@@ -0,0 +1,3 @@
+module IntercomExport
+  VERSION = '0.0.1'
+end

data/spec/intercom_export/cli_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'intercom_export/cli'
+require 'intercom_export/coordinator'
+
+RSpec.describe IntercomExport::Cli do
+
+  let(:coordinator_class) { class_double(IntercomExport::Coordinator) }
+  let(:expected_coordinator) { instance_double(IntercomExport::Coordinator) }
+
+  subject do
+    IntercomExport::Cli.new(
+      'the_program_name',
+      [
+        '--intercom-app-id', 'foobar',
+        '--intercom-api-key', 'asdf',
+        '--zendesk-address', 'example.zendesk.com',
+        '--zendesk-username', 'admin@example.com',
+        '--zendesk-token', 'secret'
+      ],
+      coordinator_class: coordinator_class
+    )
+  end
+
+  describe '#run' do
+    let(:expected_intercom_client) { instance_double(Intercom::Client) }
+    let(:expected_zendesk_client) { instance_double(ZendeskAPI::Client) }
+    let(:expected_intercom_conversation_source) {
+      instance_double(IntercomExport::Source::IntercomConversations)
+    }
+    let(:expected_intercom_splitter) { instance_double(IntercomExport::Splitter::Intercom) }
+    let(:expected_intercom_zendesk_finder) { instance_double(IntercomExport::Finder::IntercomZendesk) }
+    let(:expected_intercom_zendesk_differ) { instance_double(IntercomExport::Differ::IntercomZendesk) }
+    let(:expected_zendesk_executor) { instance_double(IntercomExport::Executor::Zendesk) }
+
+    before do
+      allow(Intercom::Client).to receive(:new)
+        .with(app_id: 'foobar', api_key: 'asdf')
+        .and_return(expected_intercom_client)
+
+      allow(ZendeskAPI::Client).to receive(:new)
+        .and_return(expected_zendesk_client)
+
+      allow(IntercomExport::Source::IntercomConversations).to receive(:new)
+        .with(expected_intercom_client)
+        .and_return(expected_intercom_conversation_source)
+
+      allow(IntercomExport::Splitter::Intercom).to receive(:new)
+        .with(expected_intercom_client)
+        .and_return(expected_intercom_splitter)
+
+      allow(IntercomExport::Finder::IntercomZendesk).to receive(:new)
+        .with(expected_zendesk_client)
+        .and_return(expected_intercom_zendesk_finder)
+
+      allow(IntercomExport::Differ::IntercomZendesk).to receive(:new)
+        .and_return(expected_intercom_zendesk_differ)
+
+      allow(IntercomExport::Executor::Zendesk).to receive(:new)
+        .with(expected_zendesk_client, anything)
+        .and_return(expected_zendesk_executor)
+    end
+
+    it 'takes the arguments and initializes the coordinator' do
+      allow(coordinator_class).to receive(:new).with(
+        source: expected_intercom_conversation_source,
+        splitter: expected_intercom_splitter,
+        finder: expected_intercom_zendesk_finder,
+        differ: expected_intercom_zendesk_differ,
+        executor: expected_zendesk_executor
+      ).and_return(expected_coordinator)
+
+      expect(expected_coordinator).to receive(:run)
+
+      subject.run
+    end
+
+    context 'when the required arguments arent specified' do
+      let(:stderr) { StringIO.new }
+
+      subject do
+        IntercomExport::Cli.new(
+          'the_program_name', ['--intercom-app-id', 'foobar'],
+          stderr: stderr
+        )
+      end
+
+      it 'prints the help' do
+        subject.run
+
+        expect(stderr.tap(&:rewind).read.length).to be > 10
+      end
+    end
+  end
+end

data/spec/intercom_export/coordinator_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'intercom_export/coordinator'
+
+require 'intercom'
+require 'zendesk_api'
+
+RSpec.describe IntercomExport::Coordinator do
+  let(:source) { ['a thing'] }
+  let(:splitter) { double('splitter') }
+  let(:finder) { double('finder') }
+  let(:differ) { double('differ') }
+  let(:executor) { double('executor') }
+
+  describe '#run' do
+    let(:expected_parts) { [double('part1', id: 1), double('part2', id: 2)] }
+    let(:expected_find_for_part2) { double('part2-found1') }
+    let(:expected_commands_for_part1) { double('part1-diffs') }
+    let(:expected_commands_for_part2) { double('part2-diffs') }
+
+    before do
+      allow(splitter).to receive(:split).with('a thing').and_return(expected_parts)
+
+      allow(finder).to receive(:find).with(expected_parts[0]).and_return(nil)
+      allow(finder).to receive(:find).with(expected_parts[1]).and_return(expected_find_for_part2)
+
+      allow(differ).to receive(:diff).with(
+        expected_parts[0], nil
+      ).and_return(expected_commands_for_part1)
+
+      allow(differ).to receive(:diff).with(
+        expected_parts[1], expected_find_for_part2
+      ).and_return(expected_commands_for_part2)
+    end
+
+    subject do
+      IntercomExport::Coordinator.new(
+        source: source, splitter: splitter, finder: finder, differ: differ, executor: executor
+      )
+    end
+
+    it 'sends the commands to the correct executor' do
+      expect(executor).to receive(:call).with(expected_commands_for_part1).ordered
+      expect(executor).to receive(:call).with(expected_commands_for_part2).ordered
+
+      subject.run
+    end
+
+    context 'with duplicate items' do
+      let(:source) { ['a thing', 'a similar thing'] }
+
+      before do
+        allow(splitter).to receive(:split).with('a similar thing').and_return(expected_parts)
+      end
+
+      it 'does minimum number of commands' do
+        expect(executor).to receive(:call).with(expected_commands_for_part1).ordered
+        expect(executor).to receive(:call).with(expected_commands_for_part2).ordered
+
+        subject.run
+      end
+    end
+  end
+end