go_import 3.0.0

data/lib/go_import/model/rootmodel.rb

@@ -0,0 +1,359 @@
+# encoding: utf-8
+module GoImport
+    # The root model for Go import. This class is the container for everything else.
+    class RootModel
+        # the import_coworker is a special coworker that is set as
+        # responsible for objects that requires a coworker, eg a note.
+        attr_accessor :import_coworker
+
+        attr_accessor :settings, :organizations, :coworkers, :deals, :notes
+
+        attr_reader :documents
+
+        def serialize_variables
+            [
+             {:id => :settings, :type => :settings},
+             {:id => :coworkers, :type => :coworkers},
+             {:id => :organizations, :type => :organizations},
+             {:id => :deals, :type => :deals},
+             {:id => :notes, :type => :notes},
+             {:id => :documents, :type => :documents},
+            ]
+        end
+
+        def serialize_name
+            "GoImport"
+        end
+
+        include SerializeHelper
+
+        def initialize()
+            @settings = Settings.new
+            @organizations = []
+            @coworkers = []
+            @import_coworker = Coworker.new
+            @import_coworker.integration_id = "import"
+            @import_coworker.first_name = "Import"
+            @coworkers.push @import_coworker
+            @deals = []
+            @notes = []
+            @documents = Documents.new
+        end
+
+        # Adds the specifed coworker object to the model.
+        # @example Add a coworker from a hash
+        #    rootmodel.add_coworker({
+        #        :integration_id=>"123",
+        #        :first_name=>"Kalle",
+        #        :last_name=>"Anka",
+        #        :email=>"kalle.anka@vonanka.com"
+        #    })
+        #
+        # @example Add a coworker from a new coworker
+        #    coworker = GoImport::Coworker.new
+        #    coworker.integration_id = "123"
+        #    coworker.first_name="Kalle"
+        #    coworker.last_name="Anka"
+        #    coworker.email = "kalle.anka@vonanka.com"
+        #    rootmodel.add_coworker(coworker)
+        #
+        # @example If you want to keep adding coworkers and dont care about duplicates not being added
+        #    begin
+        #       rootmodel.add_coworker(coworker)
+        #    rescue GoImport::AlreadyAddedError
+        #       puts "Warning: already added coworker"
+        #    end
+        # @see Coworker
+        def add_coworker(coworker)
+            @coworkers = [] if @coworkers == nil
+
+            if coworker.nil?
+                return nil
+            end
+
+            coworker = Coworker.new(coworker) if !coworker.is_a?(Coworker)
+
+            if find_coworker_by_integration_id(coworker.integration_id) != nil
+                raise AlreadyAddedError, "Already added a coworker with integration_id #{coworker.integration_id}"
+            end
+
+            @coworkers.push(coworker)
+
+            return coworker
+        end
+
+        # Adds the specifed organization object to the model.
+        # @example Add an organization from a hash
+        #    rootmodel.add_organization({
+        #        :integration_id => "123",
+        #        :name => "Beagle Boys",
+        #    })
+        #
+        # @example Add an organization from a new organization
+        #    organization = GoImport::Organization.new
+        #    organization.integration_id = "123"
+        #    organization.name = "Beagle Boys"
+        #    rootmodel.add_organization(organization)
+        #
+        # @example If you want to keep adding organizations and dont
+        # care about duplicates not being added. Your model might not
+        # be saved due to duplicate integration_ids.
+        #    begin
+        #       rootmodel.add_organization(organization)
+        #    rescue GoImport::AlreadyAddedError
+        #       puts "Warning: already added organization"
+        #    end
+        # @see Coworker
+        def add_organization(organization)
+            @organizations = [] if @organizations.nil?
+
+            if organization.nil?
+                return nil
+            end
+
+            organization = Organization.new(organization) if !organization.is_a?(Organization)
+
+            if find_organization_by_integration_id(organization.integration_id) != nil
+                raise AlreadyAddedError, "Already added an organization with integration_id #(organization.integration_id)"
+            end
+
+            @organizations.push(organization)
+
+            return organization
+        end
+
+        # Adds the specifed deal object to the model.
+        # @example Add an deal from a hash
+        #    rootmodel.add_deal({
+        #        :integration_id => "123",
+        #        :name => "Big deal",
+        #    })
+        #
+        # @example Add a deal from a new deal
+        #    deal = GoImport::Deal.new
+        #    deal.integration_id = "123"
+        #    deal.name = "Big deal"
+        #    rootmodel.add_deal(deal)
+        #
+        # @example If you want to keep adding deals and dont
+        # care about duplicates not being added. Your model might not
+        # be saved due to duplicate integration_ids.
+        #    begin
+        #       rootmodel.add_deal(deal)
+        #    rescue GoImport::AlreadyAddedError
+        #       puts "Warning: already added deal"
+        #    end
+        # @see Coworker
+        def add_deal(deal)
+            @deals = [] if @deals.nil?
+
+            if deal.nil?
+                return nil
+            end
+
+            deal = Deal.new(deal) if !deal.is_a?(Deal)
+
+            if find_deal_by_integration_id(deal.integration_id) != nil
+                raise AlreadyAddedError, "Already added a deal with integration_id #{deal.integration_id}"
+            end
+
+            if deal.responsible_coworker.nil?
+                deal.responsible_coworker = @import_coworker
+            end
+
+            @deals.push(deal)
+
+            return deal
+        end
+
+        # Adds the specifed note object to the model.
+        # @example Add an deal from a hash
+        #    rootmodel.add_note({
+        #        :integration_id => "123",
+        #        :text => "This is a note",
+        #    })
+        #
+        # @example Add a note from a new note
+        #    note = GoImport::Note.new
+        #    note.integration_id = "123"
+        #    note.text = "Big deal"
+        #    rootmodel.add_note(note)
+        #
+        # @example If you want to keep adding deals and dont
+        # care about duplicates not being added. Your model might not
+        # be saved due to duplicate integration_ids.
+        #    begin
+        #       rootmodel.add_deal(deal)
+        #    rescue GoImport::AlreadyAddedError
+        #       puts "Warning: already added deal"
+        #    end
+        # @see Coworker
+        def add_note(note)
+            @notes = [] if @notes == nil
+
+            if note.nil?
+                return nil
+             end
+
+            note = Note.new(note) if !note.is_a?(Note)
+
+            if (!note.integration_id.nil? && note.integration_id.length > 0) &&
+                    find_note_by_integration_id(note.integration_id) != nil
+                raise AlreadyAddedError, "Already added a note with integration_id #{note.integration_id}"
+            end
+
+            @notes.push(note)
+
+            return note
+        end
+
+        def add_link(link)
+            @documents = Documents.new if @documents == nil
+
+            return @documents.add_link(link)
+        end
+
+
+        def find_coworker_by_integration_id(integration_id)
+            return @coworkers.find do |coworker|
+                coworker.integration_id == integration_id
+            end
+        end
+
+        def find_organization_by_integration_id(integration_id)
+            return @organizations.find do |organization|
+                organization.integration_id == integration_id
+            end
+        end
+
+        def find_person_by_integration_id(integration_id)
+            return nil if @organizations.nil?
+            @organizations.each do |organization|
+                person = organization.find_employee_by_integration_id(integration_id)
+                return person if person
+            end
+        end
+
+        def find_note_by_integration_id(integration_id)
+            return @notes.find do |note|
+                note.integration_id == integration_id
+            end
+        end
+
+        # find deals for organization using {Organization#integration_id}
+        def find_deals_for_organization(organization)
+            deals = []
+
+            deals = @deals.select do |deal|
+                !deal.customer.nil? && deal.customer.integration_id == organization.integration_id
+            end
+
+            return deals
+        end
+
+        def find_deal_by_integration_id(integration_id)
+            return @deals.find do |deal|
+                deal.integration_id == integration_id
+            end
+        end
+
+        # Returns a string describing problems with the data. For instance if integration_id for any entity is not unique.
+        def sanity_check
+            error = String.new
+
+            dups = get_integration_id_duplicates(with_non_empty_integration_id(@coworkers))
+            dups_error_items = (dups.collect{|coworker| coworker.integration_id}).compact
+            if dups.length > 0
+                error = "#{error}\nDuplicate coworker integration_id: #{dups_error_items.join(", ")}."
+            end
+
+            dups = get_integration_id_duplicates(with_non_empty_integration_id(@organizations))
+            dups_error_items = (dups.collect{|org| org.integration_id}).compact
+            if dups.length > 0
+                error = "#{error}\nDuplicate organization integration_id: #{dups_error_items.join(", ")}."
+            end
+
+            dups = get_integration_id_duplicates(with_non_empty_integration_id(@deals))
+            dups_error_items = (dups.collect{|deal| deal.integration_id}).compact
+            if dups_error_items.length > 0
+                error = "#{error}\nDuplicate deal integration_id: #{dups_error_items.join(", ")}."
+            end
+
+            persons = @organizations.collect{|o| o.employees}.flatten.compact
+            dups = get_integration_id_duplicates(with_non_empty_integration_id(persons))
+            dups_error_items = (dups.collect{|person| person.integration_id}).compact
+            if dups_error_items.length > 0
+                error = "#{error}\nDuplicate person integration_id: #{dups_error_items.join(", ")}."
+            end
+
+            dups = get_integration_id_duplicates(with_non_empty_integration_id(@documents.links))
+            dups_error_items = (dups.collect{|l| l.integration_id}).compact
+            if dups_error_items.length > 0
+                error = "#{error}\nDuplicate link integration_id: #{dups_error_items.join(", ")}."
+            end
+
+            return error.strip
+        end
+
+        def validate()
+            error = String.new
+
+            @organizations.each do |o|
+                validation_message = o.validate()
+
+                if !validation_message.empty?
+                    error = "#{error}\n#{validation_message}"
+                end
+            end
+
+            @deals.each do |deal|
+                validation_message = deal.validate
+
+                if !validation_message.empty?
+                    error = "#{error}\n#{validation_message}"
+                end
+            end
+
+            @notes.each do |note|
+                validation_message = note.validate
+
+                if !validation_message.empty?
+                    error = "#{error}\n#{validation_message}"
+                end
+            end
+
+            @documents.links.each do |link|
+                validation_message = link.validate
+                if !validation_message.empty?
+                    error = "#{error}\n#{validation_message}"
+                end
+            end
+
+            return error.strip
+        end
+
+        # @!visibility private
+        def to_rexml(doc)
+            element_name = serialize_name
+            elem = doc.add_element(element_name,{"Version"=>"v2_0"})
+            SerializeHelper::serialize_variables_rexml(elem, self)
+        end
+
+        private
+        # returns all items from the object array with duplicate integration ids.
+        # To get all organizations with the same integration_id use
+        # @example Get all the organization duplicates with the same integration id
+        #      rm.get_integration_id_duplicates(rm.organizations)
+        def get_integration_id_duplicates(objects)
+            uniq_items = objects.uniq {|item| item.integration_id}.compact
+
+            return (objects - uniq_items).compact
+        end
+
+        def with_non_empty_integration_id(objects)
+            return objects.select do |obj|
+                obj.integration_id != nil && !obj.integration_id.empty?
+            end
+        end
+    end
+end

data/lib/go_import/model/settings.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module GoImport
+    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/go_import/model/tag.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module GoImport
+    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/go_import/model_helpers.rb

@@ -0,0 +1,54 @@
+module GoImport
+    module ModelHasCustomFields
+        # @example
+        #     value = row['business_value_partner_info']
+        #     obj.set_custom_value("partner_info", value)
+        def set_custom_value(integration_id, value)
+            return set_custom_field({integration_id: integration_id, value: value})
+        end
+        # @example
+        #     value = row['business_value_partner_info']
+        #     obj.set_custom_field({:integration_id=>"partner_info", :value=>value})
+        def set_custom_field(obj)
+            @custom_values = [] if @custom_values == nil
+            value = obj[:value]
+            field = CustomFieldReference.new(obj)
+            custom_value = CustomValue.new
+            custom_value.value = value
+            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 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
+        # @example
+        #     obj.set_tag("partner")
+        def set_tag(str)
+            @tags = [] if @tags == nil
+            if ! @tags.any? {|tag| tag.value == str }
+                @tags.push(Tag.new(str))
+            end
+        end
+    end
+end

data/lib/go_import/phone_helper.rb

@@ -0,0 +1,74 @@
+require 'global_phone'
+
+module GoImport
+    # 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 = GoImport::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 = GoImport::PhoneHelper.parse_numbers(source, '/')
+        def self.parse_numbers(number_string, delimiters = ',', strict_mode = false)
+            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/go_import/roo_helper.rb

@@ -0,0 +1,80 @@
+require "csv"
+module GoImport
+    # @example transform xlsx file into rows
+    #     organizations_path = File.join(File.dirname(__FILE__), 'organizations.xlsx') # same path as this file
+    #     rows = GoImport::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'.
+        #    GoImport::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 = GoImport::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
+                else
+                    raise "unhandled celltype #{@data.celltype(row,col,sheet)} for cell at row: #{row}, col: #{col} in sheet #{sheet}"
+                end || ""
+            end
+        end
+    end
+end