move-to-go 5.0.0

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

@@ -0,0 +1,63 @@
+require 'iso_country_codes'
+module MoveToGo
+    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
+                begin
+                    IsoCountryCodes.search_by_name(name).first.alpha2
+                rescue
+                    nil
+                end
+            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/move-to-go/model/class_settings.rb

@@ -0,0 +1,50 @@
+# Encoding: utf-8
+module MoveToGo
+    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/move-to-go/model/clientvisit.rb

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

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

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

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module MoveToGo
+    class Coworker < CanBecomeImmutable
+        include SerializeHelper
+        immutable_accessor :id
+        immutable_accessor :integration_id
+        immutable_accessor :email
+        immutable_accessor :first_name
+        immutable_accessor :last_name
+        immutable_accessor :direct_phone_number
+        immutable_accessor :mobile_phone_number
+        immutable_accessor :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/move-to-go/model/coworker_reference.rb

@@ -0,0 +1,33 @@
+module MoveToGo
+    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/move-to-go/model/customfield.rb

@@ -0,0 +1,87 @@
+module MoveToGo
+    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/move-to-go/model/deal.rb

@@ -0,0 +1,216 @@
+module MoveToGo
+    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 < CanBecomeImmutable
+        include SerializeHelper, ModelHasCustomFields, ModelHasTags
+
+        # Get/set the deal's status. Statuses must be configured in
+        # LIME Go before the import.
+        immutable_accessor :status
+
+        immutable_accessor :id
+        immutable_accessor :integration_id
+        immutable_accessor :name
+        immutable_accessor :description
+        immutable_accessor :probability
+        immutable_accessor :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_reference, :type => :organization_reference, :element_name => :customer },
+                 { :id => :responsible_coworker_reference, :type => :coworker_reference, :element_name => :responsible_coworker },
+                 { :id => :customer_contact_reference, :type => :person_reference, :element_name => :customer_contact},
+                 { :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
+
+            set_tag 'Import'
+        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(labels = nil)
+            error = String.new
+            warnings = 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 !@status.nil? && !@status.status_reference.nil? && (labels.nil? || (!labels.nil? && !labels.include?(@status.status_reference.label)))
+                warnings = "Deal status '#{@status.status_reference.label}' missing, add to settings"
+            end
+
+            if error.length > 0
+                error = "#{error}\n#{serialize()}"
+            end
+
+            return [error, warnings]
+        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 integration id (Integer) here.
+        def status=(status)
+            raise_if_immutable
+            @status = DealStatus.new if @status.nil?
+            
+            @status.status_reference = DealStatusReference.from_deal_status(status)
+        end
+
+        def customer=(customer)
+            raise_if_immutable
+            @customer_reference = OrganizationReference.from_organization(customer)
+
+            if customer.is_a?(Organization)
+                @customer = customer
+            end
+        end
+
+        # Gets the customer to which this deal belongs
+        def customer()
+            return @customer
+        end
+
+        def responsible_coworker=(coworker)
+            raise_if_immutable
+            @responsible_coworker_reference = CoworkerReference.from_coworker(coworker)
+
+            if coworker.is_a?(Coworker)
+                @responsible_coworker = coworker
+            end
+        end
+
+        def customer_contact=(person)
+            raise_if_immutable
+            @customer_contact_reference = PersonReference.from_person(person)
+
+            if person.is_a?(Person)
+                @customer_contact = person
+            end
+        end
+
+        # Sets the deal's value. Both . and , are treated as thousand
+        # separators and thus cents and other fractions will be
+        # ignored. This makes it easier for us to convert a string
+        # into an integer value.
+        def value=(value)
+            raise_if_immutable
+            
+            if value.nil?
+                @value = "0"
+            elsif value.respond_to?(:empty?) && value.empty?
+                @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.to_s.gsub(" ", "")
+
+                # we assume that both , and . are thousand separators
+                # and remove them from the value string. We dont care
+                # about decimal separators since the value is a deal's
+                # value which is much larger than cents and ores.
+                fixed_value = fixed_value.gsub(",", "")
+                fixed_value = fixed_value.gsub(".", "")
+
+                if is_integer?(fixed_value)
+                    @value = fixed_value
+                elsif fixed_value.length == 0
+                    @value = "0"
+                else
+                    raise InvalidValueError, value
+                end
+            end
+        end
+
+        def is_integer?(value)
+            true if Integer(value) rescue false
+        end
+    end
+end

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

@@ -0,0 +1,97 @@
+# encoding: utf-8
+require_relative 'class_settings'
+
+module MoveToGo
+    class DealClassSettings < ClassSettings
+        attr_reader :statuses
+
+        attr_reader :default_status
+
+        
+
+        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 },
+                       {:id => :default_status, :type => :deal_status_reference}
+                      ] 
+        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
+
+        # Sets the default status for new deals. When a deal is
+        # created in LIME Go it will get this status. Valid values are
+        # an integration_id or label. The status must exist or be
+        # created with this import.
+        def default_status=(status)
+            if status.nil?
+                return
+            end
+
+            if status.is_a?(DealStatusReference)
+                @default_status = status
+            else
+                @default_status = DealStatusReference.from_deal_status(status)
+            end
+        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/move-to-go/model/deal_state.rb

@@ -0,0 +1,15 @@
+module MoveToGo
+    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/move-to-go/model/deal_status.rb

@@ -0,0 +1,23 @@
+module MoveToGo
+    class DealStatus
+        include SerializeHelper
+
+        attr_accessor :id, :date, :status_reference, :history
+
+        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, :history ].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