go_import 3.0.0

data/lib/go_import/model/address.rb

@@ -0,0 +1,61 @@
+require 'iso_country_codes'
+module GoImport
+    class Address 
+        attr_accessor :street, :zip_code, :city, :country_code, :location
+        def serialize_variables
+            [ :street, :zip_code, :city, :country_code, :location].map {|p| {:id=>p,:type=>:string} }
+        end
+        include SerializeHelper
+        def initialize()
+        end
+
+        # What fields/rows on the class is supposed to be used by the Gem to generate the xml
+        # This method uses {#serialize_variables}. It also adds {#country_name} to be serialized
+        def get_import_rows
+            (serialize_variables+[{:id=>:country_name, :type=>:string}]).map do |p|
+                map_to_row p
+            end
+        end
+        # Used as a convenience in order to get country code from internally used {#country_code}
+        def country_name
+            if @country_code
+                IsoCountryCodes.find(@country_code).name
+            else
+                nil
+            end
+        end
+
+        # Used as a convenience in order to map country name to the internal {#country_code}
+        def country_name=(name)
+            @country_code = case name
+            when nil
+                nil
+            when 'Sverige'
+                'SE'
+            else
+                 IsoCountryCodes.search_by_name(name).first.alpha2
+            end
+        end
+        # parses a line like "226 48 LUND" into its corresponding
+        # zipcode and city properties on the address
+        def parse_zip_and_address_se(line)
+            Address.parse_line_to_zip_and_address_se(line, self)
+        end
+
+        private
+        def self.parse_line_to_zip_and_address_se(line, address)
+            matched_zipcode = /^\d{3}\s?\d{2}/.match(line)
+            if matched_zipcode && matched_zipcode.length == 1
+                address.zip_code = matched_zipcode[0].strip()
+                matched_city = /\D*$/.match(line)
+                if matched_city && matched_city.length == 1
+                    address.city = matched_city[0].strip()
+                    return address
+                end
+            end
+            return nil
+        end
+
+
+    end
+end

data/lib/go_import/model/class_settings.rb

@@ -0,0 +1,50 @@
+# Encoding: utf-8
+module GoImport
+    class ClassSettings
+        include SerializeHelper
+        attr_reader :custom_fields
+
+        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
+            [{:id => :custom_fields, :type => :custom_fields} ]
+        end
+
+        def serialize_name
+            "ClassSettings"
+        end
+
+        # Set custom field. If there is already an existing custom field, then it is overwritten.
+        def set_custom_field(obj)
+            @custom_fields = [] if @custom_fields.nil?
+
+            if obj.is_a?(CustomField)
+                field = obj
+            else
+                field = CustomField.new(obj)
+            end
+
+            if field.integration_id == "" && field.id == ""
+                raise InvalidCustomFieldError, "Custom field must have either id or integration_id"
+            end
+
+            index = @custom_fields.find_index do |custom_field|
+                custom_field.same_as?(field)
+            end
+            if index
+                @custom_fields.delete_at index
+            end
+
+            @custom_fields.push field
+
+            return field
+        end
+    end
+end

data/lib/go_import/model/coworker.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+module GoImport
+    class Coworker
+        include SerializeHelper
+        attr_accessor :id, :integration_id, :email, :first_name, :last_name, :direct_phone_number,
+        :mobile_phone_number, :home_phone_number
+
+        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
+            [
+             :id, :integration_id, :email, :first_name, :last_name,
+             :direct_phone_number, :mobile_phone_number, :home_phone_number
+            ].map {|p| { :id => p, :type => :string } }
+        end
+
+        def to_reference
+            reference = CoworkerReference.new
+            reference.id = @id
+            reference.integration_id = @integration_id
+            reference.heading = "#{@first_name} #{@last_name}".strip
+
+            return reference
+        end
+
+        def serialize_name
+            "Coworker"
+        end
+
+        def ==(that)
+            if that.nil?
+                return false
+            end
+
+            if that.is_a? Coworker
+                return @integration_id == that.integration_id
+            end
+
+            return false
+        end
+
+        def parse_name_to_firstname_lastname_se(name, when_missing = '')
+            if name.nil? or name.empty?
+                @first_name = when_missing
+                return
+            end
+
+            splitted = name.split(' ')
+            @first_name = splitted[0]
+            if splitted.length > 1
+                @last_name = splitted.drop(1).join(' ')
+            end
+        end
+
+        def to_email_chars(s)
+            s.tr " åäöèé", "-aaoee"
+        end
+
+        def guess_email(domain)
+            return '' if @last_name.nil? || @last_name.empty?
+            return '' if @first_name.nil? || @first_name.empty?
+
+            firstname = to_email_chars @first_name.downcase
+            lastname = to_email_chars @last_name.downcase
+            return "#{firstname}.#{lastname}@#{domain}"
+        end
+
+    end
+end

data/lib/go_import/model/coworker_reference.rb

@@ -0,0 +1,33 @@
+module GoImport
+    class CoworkerReference
+        include SerializeHelper
+        attr_accessor :id, :heading, :integration_id
+
+        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
+            [:id, :integration_id, :heading].map {|p| {:id => p, :type => :string} }
+        end
+
+        def serialize_name
+            "CoworkerReference"
+        end
+
+        def self.from_coworker(coworker)
+            if coworker.nil?
+                return nil
+            elsif coworker.is_a?(Coworker)
+                return coworker.to_reference
+            elsif coworker.is_a?(CoworkerReference)
+                return coworker
+            end
+        end
+    end
+end

data/lib/go_import/model/customfield.rb

@@ -0,0 +1,87 @@
+module GoImport
+    class CustomFieldReference
+        include SerializeHelper, ModelWithIntegrationIdSameAs
+
+        attr_accessor :integration_id
+
+        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
+            [:integration_id].map {|p| { :id => p, :type => :string } }
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        def serialize_name
+            "CustomFieldReference"
+        end
+    end
+
+    class CustomField
+        include SerializeHelper, ModelWithIntegrationIdSameAs
+        attr_accessor :id, :integration_id, :title, :type
+
+        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
+            [:id, :integration_id, :title, :type].map {|p| { :id => p, :type => :string } }
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        def serialize_name
+            "CustomField"
+        end
+    end
+
+    class CustomValue
+        include SerializeHelper
+        attr_accessor :field, :value
+
+        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
+            [ { :id =>:field, :type => :custom_field_reference },
+                { :id =>:value, :type => :string }]
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        def serialize_name
+            "CustomValue"
+        end
+    end
+end

data/lib/go_import/model/deal.rb

@@ -0,0 +1,172 @@
+module GoImport
+    class DealReference
+        include SerializeHelper
+        attr_accessor :id, :integration_id
+        def serialize_variables
+            [ :id, :integration_id ].map { |prop| {:id => prop, :type => :string} }
+        end
+
+        def initialize(opt = nil)
+            if opt != nil
+                serialize_variables.each do |var|
+                    value = opt[var[:id]]
+                    instance_variable_set("@" + var[:id].to_s, value) if value != nil
+                end
+            end
+        end
+
+        def to_s
+            return "(#{id}, #{integration_id})"
+        end
+
+        def empty?
+            return !@integration_id && !@id
+        end
+
+        def self.from_deal(deal)
+            if deal.nil?
+                return nil
+            elsif deal.is_a?(Deal)
+                return deal.to_reference
+            elsif deal.is_a?(DealReference)
+                return deal
+            end
+        end
+    end
+
+    class Deal
+        include SerializeHelper, ModelHasCustomFields, ModelHasTags
+
+        # Get/set the deal's status. Statuses must be configured in
+        # LIME Go before the import.
+        attr_accessor :status
+
+        attr_accessor :id, :integration_id, :name, :description, :probability, :order_date
+
+        # you add custom values by using {#set_custom_value}
+        attr_reader :custom_values
+
+        attr_reader :customer, :responsible_coworker, :customer_contact, :value
+
+        def serialize_variables
+            [ :id, :integration_id, :name, :description, :probability, :value, :order_date ].map {
+                |p| {
+                    :id => p,
+                    :type => :string
+                }
+            } +
+                [
+                 { :id => :customer, :type => :organization_reference },
+                 { :id => :responsible_coworker, :type => :coworker_reference },
+                 { :id => :customer_contact, :type => :person_reference },
+                 { :id => :custom_values, :type => :custom_values },
+                 { :id => :tags, :type => :tags },
+                 { :id => :status, :type => :deal_status }
+                ]
+        end
+
+        def serialize_name
+            "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 to_s
+            return "deal[id=#{@id}, integration_id=#{@integration_id}]"
+        end
+
+        def to_reference
+            reference = DealReference.new
+            reference.id = @id
+            reference.integration_id = @integration_id
+            return reference
+        end
+
+        def validate
+            error = String.new
+
+            if @name.nil? || @name.empty?
+                error = "A name is required for deal.\n}"
+            end
+
+            if !@status.nil? && @status.status_reference.nil?
+                error = "#{error}\nStatus must have a status reference."
+            end
+
+            if !@status.nil? && !@status.status_reference.nil? && @status.status_reference.validate.length > 0
+                error = "#{error}\n#{@status.status_reference.validate}"
+            end
+
+            if error.length > 0
+                error = "#{error}\n#{serialize()}"
+            end
+
+            return error
+        end
+
+
+        def with_status
+            @status = DealStatus.new if @status.nil?
+            yield @status
+        end
+
+        # Sets the deal's status to the specifed status. The specifed
+        # status could be either a DealStatusSetting, a string or an
+        # integer. Use DealStatusSetting if you want to create new
+        # statuses during import (you will probably add the
+        # DealStatusSettings to the settings model). If the statuses
+        # already exists in the application use the status label
+        # (String) or id (Integer) here.
+        def status=(status)
+            @status = DealStatus.new if @status.nil?
+
+            @status.status_reference = DealStatusReference.from_deal_status(status)
+        end
+
+        def customer=(customer)
+            @customer = OrganizationReference.from_organization(customer)
+        end
+
+        def responsible_coworker=(coworker)
+            @responsible_coworker = CoworkerReference.from_coworker(coworker)
+        end
+
+        def customer_contact=(person)
+            @customer_contact = PersonReference.from_person(person)
+        end
+
+        def value=(value)
+            if value.nil?
+                @value = 0
+            else
+                # we have had some issues with LIME Easy imports where
+                # the value was in the format "357 000". We need to
+                # remove those spaces.
+                fixed_value = value.gsub(" ", "")
+
+                if is_integer?(fixed_value)
+                    @value = fixed_value
+                elsif is_float?(fixed_value)
+                    @value = fixed_value
+                else
+                    raise InvalidValueError, value
+                end
+            end
+        end
+
+        def is_integer?(value)
+            true if Integer(value) rescue false
+        end
+
+        def is_float?(value)
+            true if Float(value) rescue false
+        end
+    end
+end

data/lib/go_import/model/deal_class_settings.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+module GoImport
+    class DealClassSettings < ClassSettings
+        attr_reader :statuses
+
+        def initialize(opt = nil)
+            @statuses = []
+            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
+            super() + [{:id => :statuses, :type => :statuses }]
+        end
+
+        def add_status(obj)
+            @statuses = [] if @statuses.nil?
+
+            if obj.is_a?(DealStatusSetting)
+                status = obj
+            else
+                status = DealStatusSetting.new(obj)
+            end
+
+            if status.label.nil? || status.label.empty?
+                raise InvalidDealStatusError, "Deal status must have a label"
+            end
+
+            if status.assessment.nil?
+                status.assessment = DealState::NotAnEndState
+            end
+
+            index = @statuses.find_index do |deal_status|
+                deal_status.same_as?(status)
+            end
+            if index
+                @statuses.delete_at index
+            end
+
+            @statuses.push status
+
+            return status
+        end
+
+        def find_status_by_label(label)
+            return nil if @statuses.nil? || label.nil?
+
+            return @statuses.find do |status|
+                !status.label.nil? && status.label.casecmp(label) == 0
+            end
+        end
+
+        def find_status_by_integration_id(integration_id)
+            return nil if @statuses.nil? || integration_id.nil?
+
+            return @statuses.find do |status|
+                !status.integration_id.nil? && status.integration_id.casecmp(integration_id) == 0
+            end
+        end
+
+        def find_status_by_id(id)
+            return nil if @statuses.nil?
+
+            return @statuses.find do |status|
+                !status.id.nil? && status.id.casecmp(integration_id) == 0
+            end
+        end
+    end
+end

data/lib/go_import/model/deal_state.rb

@@ -0,0 +1,15 @@
+module GoImport
+    module DealState
+        # This is the default, a deal with a status with this state is
+        # currently being worked on.
+        NotAnEndState = 0
+
+        # The deal has reached a positive end state, eg we have won
+        # the deal.
+        PositiveEndState = 1
+
+        # The deal has reached a negative end state, eg we have lost
+        # the deal.
+        NegativeEndState = -1
+    end
+end

data/lib/go_import/model/deal_status.rb

@@ -0,0 +1,23 @@
+module GoImport
+    class DealStatus
+        include SerializeHelper
+
+        attr_accessor :id, :date, :status_reference, :note
+
+        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
+            [ :id, :label, :note ].map{ |p| { :id => p, :type => :string } } +
+                [ :date ].map { |p| { :id => p, :type => :date } } +
+                [ :status_reference ].map { |p| { :id => p, :type => :deal_status_reference } }
+        end
+
+    end
+end

data/lib/go_import/model/deal_status_reference.rb

@@ -0,0 +1,47 @@
+module GoImport
+    class DealStatusReference
+        include SerializeHelper
+
+        attr_accessor :label, :integration_id
+
+        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
+            [:integration_id, :label].map {|p| {:id => p, :type => :string} }
+        end
+
+        def serialize_name
+            "StatusReference"
+        end
+
+        # Converts the specifed status to a status reference.
+        def self.from_deal_status(deal_status)
+            if deal_status.nil?
+                return nil
+            elsif deal_status.is_a?(DealStatusSetting)
+                return deal_status.to_reference
+            elsif deal_status.is_a?(String)
+                return DealStatusReference.new({:label => deal_status, :integration_id => deal_status})
+            end
+
+            raise InvalidDealStatusError
+        end
+
+        def validate
+            error = ""
+
+            if (@label.nil? || @label.empty?) && (@integration_id.nil? || @integration_id.empty?)
+                error = "label and integration_id can't all be nil or empty"
+            end
+
+            return error
+        end
+    end
+end

data/lib/go_import/model/deal_status_setting.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module GoImport
+    class DealStatusSetting
+        include SerializeHelper
+
+        attr_accessor :id, :integration_id, :label, :assessment
+
+        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
+            [ :id, :integration_id, :label, :assessment ].map{ |p| { :id => p, :type => :string } }
+        end
+
+        def serialize_name
+            "DealStatus"
+        end
+
+        def to_reference()
+            reference = DealStatusReference.new
+            reference.label = @label
+            reference.integration_id = @integration_id
+
+            return reference
+        end
+
+        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
+
+            if @label != nil && @label == other.label
+                return true
+            end
+
+            return false
+        end
+    end
+end