fruit_to_lime 0.8.2 → 0.9.0

data/lib/fruit_to_lime/model/rootmodel.rb

@@ -1,39 +1,142 @@
-module FruitToLime
-    class RootModel
-        attr_accessor :organizations, :coworkers, :deals
-        def serialize_variables
-            [
-                {:id=>:organizations,:type=>:organizations},
-                {:id=>:coworkers, :type=>:coworkers}
-            ]
-        end
-        def serialize_name
-            "GoImport"
-        end
-        include SerializeHelper
-        def initialize()
-            @organizations = []
-            @coworkers = []
-        end
-        def find_organization_by_reference(organization_reference)
-            same_as_this = organization_reference.same_as_this_method
-            return @organizations.find do |org|
-                same_as_this.call(org)
-            end
-        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
-
-            return error
-        end
-    end
-end
+module FruitToLime
+    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 :organizations, :coworkers, :deals, :notes, :import_coworker
+        def serialize_variables
+            [
+             {:id => :coworkers, :type => :coworkers},
+             {:id => :organizations, :type => :organizations},
+             {:id => :deals, :type => :deals},
+             {:id => :notes, :type => :notes},
+            ]
+        end
+
+        def serialize_name
+            "GoImport"
+        end
+
+        include SerializeHelper
+
+        def initialize()
+            @organizations = []
+            @coworkers = []
+            @import_coworker = Coworker.new
+            @import_coworker.integration_id = "import"
+            @import_coworker.first_name = "Import"
+            @coworkers.push @import_coworker
+            @deals = []
+            @notes = []
+        end
+
+        # Adds the specifed coworker object to the model.
+        def add_coworker(coworker)
+            @coworkers = [] if @coworkers == nil
+
+            if coworker != nil && coworker.is_a?(Coworker) && !@coworkers.include?(coworker)
+                @coworkers.push(coworker)
+            end
+        end
+
+        def add_note(text)
+            @notes = [] if @notes == nil
+            @notes.push(if text.is_a? Note then text else Note.new(text) end)
+        end
+
+        def with_note
+            @notes = [] if @notes == nil
+
+            note = Note.new
+            @notes.push note
+            yield note
+        end
+
+        # *** TODO:
+        #
+        # delete find_organization_by_reference and
+        #same_as_this_method from organization?
+        def find_organization_by_reference(organization_reference)
+            same_as_this = organization_reference.same_as_this_method
+            return @organizations.find do |org|
+                same_as_this.call(org)
+            end
+        end
+
+        def find_coworker_by_integration_id(integration_id)
+            return @coworkers.find do |coworker|
+                coworker == integration_id
+            end
+        end
+
+        def find_organization_by_integration_id(integration_id)
+            return @organizations.find do |organization|
+                organization == integration_id
+            end
+        end
+
+        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 sanity_check
+            error = String.new
+
+            dups = get_duplicates(@coworkers) {|coworker| coworker.integration_id}
+            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_duplicates(@organizations) {|org| org.integration_id}
+            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_duplicates(@deals) {|deal| deal.integration_id}
+            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
+
+            return error.strip
+        end
+
+        # returns all items from the object array with duplicate keys.
+        # To get all organizations with the same integration_id use
+        # get_duplicates(organizations, {|org| org.integration_id})
+        def get_duplicates(objects, &key)
+            uniq_items = objects.uniq {|item| key.call(item)}.compact
+
+            return (objects - uniq_items).compact
+        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
+
+            return error.strip
+        end
+    end
+end

data/lib/fruit_to_lime/model/tag.rb

@@ -1,28 +1,33 @@
-# encoding: utf-8
-module FruitToLime
-    class Tag
-    	def serialize_name
-            "Tag"
-        end
-    	attr_accessor :value
-    	def initialize(val=nil)
-    		if val
-    			@value = val
-    		end
-    	end
-  		def to_xml
-  			varn = serialize_name
-            "<#{varn}>#{ @value.to_s.encode('utf-8').encode(:xml => :text) }</#{varn}>"
-  		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
+# encoding: utf-8
+module FruitToLime
+    class Tag
+        def serialize_name
+            "Tag"
+        end
+
+        attr_accessor :value
+
+        def initialize(val=nil)
+            if val
+                @value = val
+            end
+        end
+
+        def to_xml
+            varn = serialize_name
+            "<#{varn}>#{ @value.to_s.encode('utf-8').encode(:xml => :text) }</#{varn}>"
+        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/fruit_to_lime/model_helpers.rb

@@ -0,0 +1,19 @@
+module FruitToLime
+    module ModelHasCustomFields
+        #        attr_reader :custom_fields
+
+        #@custom_fields = []
+
+        def set_custom_field(obj)
+            @custom_fields = [] if @custom_fields==nil
+            @custom_fields.push CustomField.new(obj)
+        end
+    end
+
+    module ModelHasTags
+        def add_tag(str)
+            @tags = [] if @tags == nil
+            @tags.push(Tag.new(str))
+        end
+    end
+end

data/lib/fruit_to_lime/roo_helper.rb

@@ -1,54 +1,59 @@
-require "csv"
-module FruitToLime
-    class RooHelper
-        def initialize(data)
-            @data = data
-            @sheet = data.sheets.first
-            @map = {}
-            1.upto(data.last_column(@sheet)) do |col|
-               @map[col] = @data.cell(1, col, @sheet).encode('UTF-8')
-            end
-        end
-
-        def rows
-            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[@map[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')
-                    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
+require "csv"
+module FruitToLime
+    class RooHelper
+        def initialize(data)
+            @data = data
+            @default_sheet = data.sheets.first
+        end
+
+        def rows
+            return rows_for_sheet(@default_sheet)
+        end
+
+        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

data/lib/fruit_to_lime/serialize_helper.rb

@@ -1,139 +1,139 @@
-# encoding: utf-8
-module FruitToLime
-module SerializeHelper
-
-    def serialize()
-        SerializeHelper::serialize(self)
-    end
-
-    def serialize_to_file(file)
-        SerializeHelper::serialize_to_file(file, self)
-    end
-
-    def self.serialize_variables(obj)
-        if (obj.respond_to?(:serialize_variables))
-            return obj.serialize_variables.map do |ivar|
-                varn = ivar[:id].to_s.gsub(/^\@/,'').split('_').map do |m|
-                    m.capitalize
-                end.join('')
-                varv = obj.instance_variable_get("@#{ivar[:id].to_s}")
-                if (varv.respond_to?(:serialize_variables))
-                    varv = serialize_variables(varv)
-                elsif (varv.is_a?(Array))
-                    varv = varv.map { |elem| SerializeHelper::serialize(elem) }.join("\n")
-                elsif (varv == nil)
-                    varv = nil
-                else
-                    varv = varv.to_s.encode('UTF-8').encode(:xml => :text)
-                end
-                if varv != nil then "<#{varn}>#{ varv }</#{varn}>" else "" end
-                if varv != nil then "<#{varn}>#{ varv }</#{varn}>" end
-            end.join("\n")
-        end
-        raise "!!#{obj.class}"
-    end
-
-    def self.serialize(obj)
-        if (obj.respond_to?(:serialize_variables))
-            varn = obj.serialize_name
-            "<#{varn}>#{ SerializeHelper::serialize_variables(obj) }</#{varn}>"
-        elsif obj.respond_to?(:to_xml)
-            obj.to_xml
-        else
-            obj.to_s.encode(:xml => :text)
-        end
-    end
-
-    def self.serialize_to_file(file, obj)
-        File.open(file, 'w') do |f|
-            f.write(SerializeHelper::serialize(obj))
-        end
-    end
-
-    def symbol_to_name(symbol)
-        symbol.to_s.split('_').join(' ').capitalize
-    end
-
-    def map_symbol_to_row(symbol,type)
-        {
-            :id=>symbol.to_s,
-            :name=> symbol==:id ? 'Go id' : symbol_to_name(symbol),
-            :type=>type
-        }
-    end
-
-    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 :notes then
-            {
-                :id => p[:id].to_s,
-                :name => symbol_to_name(p[:id]),
-                :type => p[:type],
-                :models => SerializeHelper.get_import_rows(:note)
-            }
-        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)
-            }
-        else
-            {
-                :id => p[:id].to_s,
-                :name => symbol_to_name(p[:id]),
-                :type => p[:type],
-                :model => SerializeHelper.get_import_rows(p[:type])
-            }
-        end
-    end
-
-    def get_import_rows
-        serialize_variables.map do |p|
-            map_to_row p
-        end
-    end
-
-    def self.get_import_rows(type)
-        case type
-        when :person then
-            Person.new
-        when :source_ref then
-            ReferenceToSource.new
-        when :note then
-            Note.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
-        else
-            raise "Unknown type: #{type}"
-        end.get_import_rows
-    end
-end
-end
+# encoding: utf-8
+module FruitToLime
+    module SerializeHelper
+        def serialize()
+            SerializeHelper::serialize(self)
+        end
+
+        def serialize_to_file(file)
+            SerializeHelper::serialize_to_file(file, self)
+        end
+
+        def self.serialize_variables(obj)
+            if (obj.respond_to?(:serialize_variables))
+                return obj.serialize_variables.map do |ivar|
+                    varn = ivar[:id].to_s.gsub(/^\@/,'').split('_').map do |m|
+                        m.capitalize
+                    end.join('')
+
+                    varv = obj.instance_variable_get("@#{ivar[:id].to_s}")
+                    if (varv.respond_to?(:serialize_variables))
+                        varv = serialize_variables(varv)
+                    elsif (varv.is_a?(Array))
+                        varv = varv.map { |elem| SerializeHelper::serialize(elem) }.join("\n")
+                    elsif (varv == nil)
+                        varv = nil
+                    else
+                        varv = varv.to_s.encode('UTF-8').encode(:xml => :text)
+                    end
+                    if varv != nil then "<#{varn}>#{ varv }</#{varn}>" else "" end
+                    if varv != nil then "<#{varn}>#{ varv }</#{varn}>" end
+                end.join("\n")
+            end
+            raise "!!#{obj.class}"
+        end
+
+        def self.serialize(obj)
+            if (obj.respond_to?(:serialize_variables))
+                varn = obj.serialize_name
+                "<#{varn}>#{ SerializeHelper::serialize_variables(obj) }</#{varn}>"
+            elsif obj.respond_to?(:to_xml)
+                obj.to_xml
+            else
+                obj.to_s.encode(:xml => :text)
+            end
+        end
+
+        def self.serialize_to_file(file, obj)
+            File.open(file, 'w') do |f|
+                f.write(SerializeHelper::serialize(obj))
+            end
+        end
+
+        def symbol_to_name(symbol)
+            symbol.to_s.split('_').join(' ').capitalize
+        end
+
+        def map_symbol_to_row(symbol,type)
+            {
+                :id => symbol.to_s,
+                :name => symbol == :id ? 'Go id' : symbol_to_name(symbol),
+                :type =>type
+            }
+        end
+
+        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 :notes then
+                {
+                    :id => p[:id].to_s,
+                    :name => symbol_to_name(p[:id]),
+                    :type => p[:type],
+                    :models => SerializeHelper.get_import_rows(:note)
+                }
+            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)
+                }
+            else
+                {
+                    :id => p[:id].to_s,
+                    :name => symbol_to_name(p[:id]),
+                    :type => p[:type],
+                    :model => SerializeHelper.get_import_rows(p[:type])
+                }
+            end
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        def self.get_import_rows(type)
+            case type
+            when :person then
+                Person.new
+            when :source_ref then
+                ReferenceToSource.new
+            when :note then
+                Note.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
+            else
+                raise "Unknown type: #{type}"
+            end.get_import_rows
+        end
+    end
+end