move-to-go 5.0.0

data/lib/move-to-go/model/settings.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module MoveToGo
+    class Settings
+        include SerializeHelper
+        attr_reader :organization, :person, :deal
+
+        # @example Add custom fields available for organization
+        #    rootmodel.settings.with_organization do |organization_settings|
+        #        organization_settings.set_custom_field({:integration_id=>"link_to_bi_system", :title=>"Link to BI system"})
+        #        organization_settings.set_custom_field({:integration_id=>"yield_quota", :title=>"Yield quota"})
+        #    end
+        # @see ClassSettings
+        # @see CustomField
+        # @see RootModel
+        def with_organization
+            @organization = ClassSettings.new if @organization ==nil
+            yield @organization
+        end
+
+        # @example Add custom fields available for person
+        #    rootmodel.settings.with_person do |person_settings|
+        #        person_settings.set_custom_field({:integration_id=>"link_to_bi_system", :title=>"Link to BI system"})
+        #    end
+        # @see ClassSettings
+        # @see CustomField
+        # @see RootModel
+        def with_person
+            @person = ClassSettings.new if @person ==nil
+            yield @person
+        end
+
+        # @example Add custom fields available for deal
+        #    rootmodel.settings.with_deal do |deal_settings|
+        #        deal_settings.set_custom_field({:integration_id=>"link_to_bi_system", :title=>"Link to BI system"})
+        #    end
+        # @see ClassSettings
+        # @see CustomField
+        # @see RootModel
+        def with_deal
+            @deal = DealClassSettings.new if @deal ==nil
+            yield @deal
+        end
+
+        def initialize(opt = nil)
+            if opt != nil
+                serialize_variables.each do |myattr|
+                    val = opt[myattr[:id]]
+                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
+                end
+            end
+        end
+
+        def serialize_variables
+            [:organization, :person, :deal].map {|p| {:id => p, :type => :class_settings} }
+        end
+
+        def serialize_name
+            "Settings"
+        end
+    end
+end

data/lib/move-to-go/model/tag.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module MoveToGo
+    class Tag
+        def serialize_name
+            "Tag"
+        end
+
+        attr_accessor :value
+
+        def initialize(val=nil)
+            if val
+                @value = val
+            end
+        end
+        
+        # @!visibility private
+        def to_rexml(elem)
+            element_name = serialize_name
+            elem.add_element(element_name).text = @value.to_s.encode('utf-8')
+        end
+
+        def to_s
+            return "tag: '#{@value}'"
+        end
+
+        def ==(other)
+            if other.respond_to?(:value)
+                return @value == other.value
+            else
+                return false
+            end
+        end
+    end
+end

data/lib/move-to-go/model/talkedto.rb

@@ -0,0 +1,10 @@
+require_relative 'history'
+module MoveToGo
+    class TalkedTo < History
+        def initialize(opt = nil)
+            super(opt)
+
+            @classification = HistoryClassification::TalkedTo
+        end
+    end
+end

data/lib/move-to-go/model/triedtoreach.rb

@@ -0,0 +1,10 @@
+require_relative 'history'
+module MoveToGo
+    class TriedToReach < History
+        def initialize(opt = nil)
+            super(opt)
+
+            @classification = HistoryClassification::TriedToReach
+        end
+    end
+end

data/lib/move-to-go/model_helpers.rb

@@ -0,0 +1,97 @@
+module MoveToGo
+    module ModelHasCustomFields
+        # @example
+        #     value = row['business_value_partner_info']
+        #     obj.set_custom_value("external_url", "https://www.somecompany.com")        
+        def set_custom_value(integration_id, value)
+            @custom_values = [] if @custom_values == nil
+
+            if value.nil?
+                return
+            end
+
+            valueAsString = value.to_s
+            if valueAsString.length == 0
+                return
+            end
+            
+            field = CustomFieldReference.new({:integration_id => integration_id})
+            custom_value = CustomValue.new
+            custom_value.value = valueAsString
+            custom_value.field = field
+
+            index = @custom_values.find_index do |custom_value|
+                custom_value.field.same_as?(field)
+            end
+
+            if index
+                @custom_values.delete_at index
+            end
+
+            @custom_values.push custom_value
+            return custom_value
+        end
+    end
+
+    module ImmutableModel
+        @is_immutable = false
+        def self.immutable_accessor(name)
+            define_method(name) do
+                return instance_variable_get("@#{name}")
+            end
+
+            define_method("#{name}=") do |value|
+                raise_if_immutable
+                instance_variable_set("@#{name}", value)
+            end
+        end
+
+        def raise_if_immutable
+            if @is_immutable
+                raise ObjectIsImmutableError
+            end
+        end
+
+        def is_immutable()
+            @is_immutable = true
+        end
+    end
+    
+    module ModelWithIntegrationIdSameAs
+        # check if other is same as regarding integration_id or id
+        def same_as?(other)
+            if @integration_id != nil && @integration_id == other.integration_id
+                return true
+            end
+            if @id != nil && @id == other.id
+                return true
+            end
+            return false
+        end
+    end
+
+    module ModelHasTags
+        attr_reader :tags
+
+        # @example
+        #     obj.set_tag("partner")
+        def set_tag(str)
+            if str.nil?
+                return
+            end
+
+            if !str.is_a?(String)
+                return
+            end
+
+            if str.length == 0
+                return
+            end
+            
+            @tags = [] if @tags == nil
+            if ! @tags.any? {|tag| tag.value == str }
+                @tags.push(Tag.new(str))
+            end
+        end
+    end
+end

data/lib/move-to-go/phone_helper.rb

@@ -0,0 +1,75 @@
+require 'global_phone'
+
+module MoveToGo
+    # The PhoneHelper helps you parse and format phone number strings
+    # into pretty looking numbers.
+    class PhoneHelper
+        GlobalPhone.db_path = ::File.join(::File.dirname(__FILE__), 'global_phone.json')
+        GlobalPhone.default_territory_name = :se
+
+        # Sets the country code used during parsning. The default is
+        # swedish (:se) and if you are parsing swedish numbers you
+        # dont need to set the country code.
+        def self.set_country_code(country_code)
+            GlobalPhone.default_territory_name = country_code
+        end
+
+        # Parses the specifed number_string and returns only valid
+        # numbers.
+        # @see parse_numbers
+        def self.parse_numbers_strict(number_string, delimiters = ',')
+            parse_numbers number_string, delimiters, true
+        end
+
+        # Parses the specified number_string into one or more phone
+        # numbers using the specified delimiters. If strict_mode is
+        # true only valid numbers are returned, otherwise are invalid
+        # numbers returned as found in the number_string.
+        #
+        # @example Parse a number
+        #    number = MoveToGo::PhoneHelper.parse_numbers("046 - 270 48 00")
+        #
+        # @example Parses a string with two numbers and a custom delimiter
+        #    source = "046 - 270 48 00/ 031-712 44 00"
+        #    number1, number2 = MoveToGo::PhoneHelper.parse_numbers(source, '/')
+        def self.parse_numbers(number_string, delimiters = ',', strict_mode = false)
+            return nil if number_string.nil?
+            numbers = []
+
+            if delimiters.is_a?(Array)
+                # we have several delimiters, replace all delimiters
+                # in the number_string with the first delimiter
+                delimiters.each do |del|
+                    number_string = number_string.sub(del, delimiters[0])
+                end
+                delimiter = delimiters[0]
+            elsif delimiters.is_a?(String)
+                delimiter = delimiters
+            else
+                raise "delimiters should be either a string or and array of strings"
+            end
+
+            number_string.split(delimiter).each do |possible_number|
+                if !possible_number.empty?
+                    number = GlobalPhone.parse([possible_number])
+
+                    if !number.nil? && number.valid?
+                        numbers.push number.to_s
+                    else
+                        if !strict_mode
+                            numbers.push possible_number
+                        end
+                    end
+                end
+            end
+
+            if numbers.length == 0
+                return ""
+            elsif numbers.length == 1
+                return numbers[0]
+            else
+                return numbers
+            end
+        end
+    end
+end

data/lib/move-to-go/roo_helper.rb

@@ -0,0 +1,82 @@
+require "csv"
+module MoveToGo
+    # @example transform xlsx file into rows
+    #     organizations_path = File.join(File.dirname(__FILE__), 'organizations.xlsx') # same path as this file
+    #     rows = MoveToGo::RooHelper.new(Roo::Excelx.new(organizations_path)).rows
+    class RooHelper
+
+        def initialize(data)
+            @data = data
+            @default_sheet = data.sheets.first
+        end
+
+        # Get rows for the first sheet.
+        # The rows are hashes of the first row of cells as header cells and the rest as content.
+        # @example If the header 'Name' and the second column contains 'Johan'.
+        #    MoveToGo::RooHelper.new(Roo::Excelx.new(file_path)).rows
+        #    # returns:
+        #    [{'Name'=>'Johan'}]
+        def rows
+            return rows_for_sheet(@default_sheet)
+        end
+
+        # Returns true if the current workbook has a sheet with the
+        # specifed name. This is case sensitive.
+        def has_sheet?(name)
+            sheet = @data.sheets.find { |s| s.to_s == name}
+
+            return !sheet.nil?
+        end
+
+        # @example transform xlsx file into rows for the second sheet
+        #     data = Roo::Excelx.new(organizations_path)
+        #     rows = MoveToGo::RooHelper.new(data).rows_for_sheet(data.sheets[1])
+        def rows_for_sheet(sheet)
+            column_headers = {}
+            1.upto(@data.last_column(sheet)) do |col|
+                column_headers[col] = @data.cell(1, col, sheet).encode('UTF-8')
+            end
+
+            rs = []
+            2.upto(@data.last_row(sheet)) do |row|
+                r = {}
+                1.upto(@data.last_column(sheet)) do |col|
+                    val = cell_to_csv(row, col, sheet)
+                    r[column_headers[col]] = val
+                end
+                rs.push(r)
+            end
+            return rs
+        end
+
+        def cell_to_csv(row, col, sheet)
+            if @data.empty?(row,col,sheet)
+                ''
+            else
+                onecell = @data.cell(row,col,sheet)
+                case @data.celltype(row,col,sheet)
+                when :string
+                    unless onecell.empty?
+                        onecell.encode('UTF-8').strip
+                    end
+                when :float, :percentage
+                    if onecell == onecell.to_i
+                      onecell.to_i.to_s
+                    else
+                      onecell.to_s
+                    end
+                when :date, :datetime
+                    onecell.to_s
+                when :time
+                    Roo::Base.integer_to_timestring(onecell)
+                when :formula
+                    onecell.to_s
+                when :link
+                    onecell.to_s
+                else
+                    raise "unhandled celltype #{@data.celltype(row,col,sheet)} for cell at row: #{row}, col: #{col} in sheet #{sheet}"
+                end || ""
+            end
+        end
+    end
+end

data/lib/move-to-go/serialize_helper.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+require "rexml/document"
+
+module MoveToGo
+    module SerializeHelper
+        def serialize()
+            SerializeHelper::serialize(self)
+        end
+
+        def serialize_to_file(file)
+            SerializeHelper::serialize_to_file(file, self)
+        end
+
+        # @!visibility private
+        def self.serialize_variables_rexml(elem, obj)
+            if (obj.respond_to?(:serialize_variables))
+                obj.serialize_variables.each do |serialize_variable|
+                    if serialize_variable[:element_name].nil?
+                        # Remove the @ and replace a _ with the next
+                        # letter capitalized. Ie @customer_reference
+                        # should be CustomerReference
+                        element_name = serialize_variable[:id].to_s.gsub(/^\@/,'').split('_').map do |m|
+                            m.capitalize
+                        end.join('')
+                    else
+                        element_name = serialize_variable[:element_name].to_s.split('_').map do |m|
+                            m.capitalize
+                        end.join('')
+                    end
+
+                    raw_var = obj.instance_variable_get("@#{serialize_variable[:id].to_s}")
+                    if raw_var != nil
+                        element = elem.add_element(element_name)
+                        if (raw_var.respond_to?(:serialize_variables))
+                            SerializeHelper::serialize_variables_rexml(element, raw_var)
+                        elsif (raw_var.is_a?(Array))
+                            raw_var.each do |raw_var_elem|
+                                SerializeHelper::serialize_rexml(element, raw_var_elem)
+                            end
+                        elsif (raw_var.is_a?(Hash))
+                            raw_var.each do |key, raw_var_elem|
+                                SerializeHelper::serialize_rexml(element, raw_var_elem)
+                            end
+                        else
+                            element.text = raw_var.to_s.encode('UTF-8')
+                        end
+                    end
+                end
+                return
+            end
+            raise "Do not know how to handle #{obj.class} !!"
+        end
+
+        # @!visibility private
+        def self.serialize_rexml(elem, obj)
+            if obj.respond_to?(:to_rexml)
+                obj.to_rexml(elem)
+            elsif (obj.respond_to?(:serialize_variables))
+                element_name = obj.serialize_name
+                SerializeHelper::serialize_variables_rexml(elem.add_element(element_name), obj)
+            else
+                elem.text = obj.to_s
+            end
+        end
+
+        # @!visibility private
+        def self.serialize(obj, indent= 2)
+            # indent -1 to avoid indent
+            if obj.respond_to?(:to_rexml)
+                doc = REXML::Document.new()
+                SerializeHelper::serialize_rexml(doc, obj)
+                doc.write( xml_str = "" , indent, true)
+                xml_str
+            elsif (obj.respond_to?(:serialize_variables))
+                element_name = obj.serialize_name
+                doc = REXML::Document.new()
+                SerializeHelper::serialize_variables_rexml(doc.add_element(element_name), obj)
+                doc.write( xml_str = "", indent, true)
+                xml_str
+            else
+                obj.to_s.encode(:xml => :text)
+            end
+        end
+
+        # @!visibility private
+        def self.serialize_to_file(file, obj)
+            ::File.open(file, 'w') do |f|
+                f.write(SerializeHelper::serialize(obj))
+            end
+        end
+
+        # @!visibility private
+        def symbol_to_name(symbol)
+            symbol.to_s.split('_').join(' ').capitalize
+        end
+
+        # @!visibility private
+        def map_symbol_to_row(symbol,type)
+            {
+                :id => symbol.to_s,
+                :name => symbol == :id ? 'Go id' : symbol_to_name(symbol),
+                :type =>type
+            }
+        end
+
+        # @!visibility private
+        def map_to_row(p)
+            case p[:type]
+            when :string then
+                map_symbol_to_row(p[:id],p[:type])
+            when :bool then
+                map_symbol_to_row(p[:id],p[:type])
+            when :date then
+                map_symbol_to_row(p[:id],p[:type])
+            when :histories then
+                {
+                    :id => p[:id].to_s,
+                    :name => symbol_to_name(p[:id]),
+                    :type => p[:type],
+                    :models => SerializeHelper.get_import_rows(:history)
+                }
+            when :tags then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                }
+            when :persons then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                    :models => SerializeHelper.get_import_rows(:person)
+                }
+            when :custom_fields then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                    :models => SerializeHelper.get_import_rows(:custom_field)
+                }
+            when :custom_values then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                    :models => SerializeHelper.get_import_rows(:custom_value)
+                }
+            else
+                {
+                    :id => p[:id].to_s,
+                    :name => symbol_to_name(p[:id]),
+                    :type => p[:type],
+                    :model => SerializeHelper.get_import_rows(p[:type])
+                }
+            end
+        end
+
+        # What fields/rows on the class is supposed to be used by the Gem to generate the xml
+        # This method uses #serialize_variables.
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        # @!visibility private
+        def self.get_import_rows(type)
+            case type
+            when :person then
+                Person.new
+            when :source_ref then
+                ReferenceToSource.new
+            when :history then
+                History.new
+            when :address then
+                Address.new
+            when :organization then
+                Organization.new
+            when :coworker_reference then
+                CoworkerReference.new
+            when :organization_reference then
+                OrganizationReference.new
+            when :custom_field then
+                CustomField.new
+            when :custom_value then
+                CustomValue.new
+            when :custom_field_reference then
+                CustomFieldReference.new
+            when :settings then
+                Settings.new
+            when :class_settings then
+                ClassSettings.new
+            else
+                raise "Unknown type: #{type}"
+            end.get_import_rows
+        end
+    end
+end

data/lib/move-to-go/shard_helper.rb

@@ -0,0 +1,96 @@
+module MoveToGo
+    class ShardHelper
+
+            attr_accessor :shards, :current_shard_count, :current_shard
+
+            def initialize(shard_size = nil)
+                @shard_size = shard_size || 25000
+                setup()
+            end
+
+            def shard_model(model)
+                @current_shard.settings = model.settings
+
+                model.coworkers.each{ |key, coworker|
+                    if coworker.integration_id != "migrator"
+                        add_coworker(coworker)
+                    end
+                }
+                model.organizations.each{|key, org| add_organization(org)}
+                model.deals.each{|key, deal| add_deal(deal)}
+                model.histories.each{|key, history| add_history(history)}
+                add_documents(model.documents)
+
+                return_value = @shards
+                setup()
+                return return_value
+            end
+
+            private
+            def setup()
+                @current_shard = MoveToGo::RootModel.new
+                @shards = [@current_shard]
+                @current_shard_count = 0
+            end
+
+            private
+            def add_history(history)
+                check_or_create_new_chard()
+                @current_shard.add_history(history)
+                @current_shard_count += 1
+            end
+
+            private
+            def add_deal(deal)
+                check_or_create_new_chard()
+                @current_shard.add_deal(deal)
+                @current_shard_count += 1
+            end
+
+            private
+            def add_coworker(coworker)
+                check_or_create_new_chard()
+                @current_shard.add_coworker(coworker)
+                @current_shard_count += 1
+            end
+
+            private
+            def add_organization(org)
+                check_or_create_new_chard()
+                if org.employees != nil
+                    @current_shard_count += org.employees.length
+                end
+                @current_shard.add_organization(org)
+                @current_shard_count += 1
+            end
+
+            private
+            def add_documents(doc)
+                    doc.files.each{|file| add_file(file)}
+                    doc.links.each{|link| add_link(link)}
+            end
+
+            private
+            def add_file(file)
+                check_or_create_new_chard()
+                @current_shard.add_file(file)
+                @current_shard_count += 1
+            end
+
+            private
+            def add_link(link)
+                check_or_create_new_chard()
+                @current_shard.add_link(link)
+                @current_shard_count += 1
+            end
+
+            private
+            def check_or_create_new_chard()
+                if @current_shard_count > @shard_size
+                    @current_shard = MoveToGo::RootModel.new
+                    @shards.push(@current_shard)
+                    @current_shard_count = 0
+                end
+            end
+    end
+end