geo_labels 0.2.0 → 0.3.2

data/app/helpers/geo_labels/application_helper.rb

@@ -1,32 +1,41 @@
+# frozen_string_literal: true
+
 module GeoLabels
   module ApplicationHelper
+    include RatingHelper
+
     def link_to_labels_tree
-      #output = "<ul class='ui list'>"
-      output = tag.ul(class: 'ui list')[0..-6]
-      add_punctuation = '*'
-      tree_formatter = Proc.new do |items, lead_space|
+      # output = "<ul class='ui list'>"
+      output = tag.ul(class: 'ui list labels-tree')[0..-6]
+      #add_punctuation = '*'
+      tree_formatter = proc do |items, lead_space|
         items.each do |item|
-          output += "#{lead_space}#{tag.li link_to(item[:name], label_path(item[:id]))}\n".html_safe
-          if item[:children].present?
-            output += "#{lead_space}<ul>".html_safe
-            tree_formatter.call(item[:children], lead_space + '  ')
-            output += "#{lead_space}</ul>".html_safe
-          end
+          label_name = link_to(item[:name], label_path(item[:id]))
+          edit_link  = table_edit_link(item, geo_labels.edit_label_path(item[:id]))
+          add_child_link = link_to(tag.i(class: 'plus icon'), geo_labels.new_label_path(parent_id: item[:id]))
+          output += "#{lead_space}#{tag.li(label_name + add_child_link + edit_link)}\n".html_safe
+          next unless item[:children].present?
+
+          output += "#{lead_space}<ul>".html_safe
+          tree_formatter.call(item[:children], "#{lead_space}  ")
+          output += "#{lead_space}</ul>".html_safe
         end
       end
       tree_formatter.call(GeoLabels::Exporter.labels_tree_h, '')
-      #output.gsub!(/^(\s*)  /, "\1#{add_punctuation} ") if add_punctuation.present?
+      # output.gsub!(/^(\s*)  /, "\1#{add_punctuation} ") if add_punctuation.present?
       output += '</ul>'.html_safe
       output.html_safe
     end
+
     # Return active or nil based on the given route spec
     #   %li{ class: active_class('users') # true if controller is users, false otherwise
     #   %li{ class: active_class('pages#about') # true if controller is pages and action is about
-    #NOTE: Taken from the dunlop-core gem. That is the best maintained version
+    # NOTE: Taken from the dunlop-core gem. That is the best maintained version
     def active_class(*route_specs)
       options = route_specs.extract_options!
-      return nil if Array.wrap(options[:except]).any?{|exception| current_route_spec?(exception) }
-      return 'active' if route_specs.any?{|rs| current_route_spec?(rs, options) }
+      return nil if Array.wrap(options[:except]).any?{ |exception| current_route_spec?(exception) }
+      return 'active' if route_specs.any?{ |rs| current_route_spec?(rs, options) }
+
       nil
     end
 
@@ -36,19 +45,23 @@ module GeoLabels
     #   current_route_spec?('products') #=> true if controller name is products, false otherwise
     #   current_route_spec?('products#show') #=> true if controller_name is products AND action_name is show
     #   current_route_spec?('#show') #=> true if action_name is show, false otherwise
-    #NOTE: this helper is tested through the active_class helper
-    #NOTE: Taken from the dunlop-core gem. That is the best maintained version
-    def current_route_spec?(route_spec, options = {})
+    # NOTE: this helper is tested through the active_class helper
+    # NOTE: Taken from the dunlop-core gem. That is the best maintained version
+    def current_route_spec?(route_spec, _options = {})
       return route_spec.match([controller_path, action_name].join('#')) if route_spec.is_a?(Regexp)
+
       controller, action = route_spec.split('#')
       return action == params[:id] if controller_path == 'high_voltage/pages'
+
       actual_controller_parts = controller_path.split('/')
-      if controller #and controller_path == controller
+      if controller # and controller_path == controller
         tested_controller_parts = controller.split('/')
         return if tested_controller_parts.size > actual_controller_parts.size
+
         if actual_controller_parts[0...tested_controller_parts.size] == tested_controller_parts
           # controller spec matches
           return true unless action
+
           action_name == action
         end
       else
@@ -56,7 +69,7 @@ module GeoLabels
       end
     end
 
-    #NOTE: Taken from the dunlop-core gem. That is the best maintained version
+    # NOTE: Taken from the dunlop-core gem. That is the best maintained version
     def page_title(*args, &blk)
       extra_content = capture(&blk) if blk.present?
       if resource_title?(args)
@@ -80,16 +93,13 @@ module GeoLabels
       title = html_escape(args.first)
       options = args.last.is_a?(Hash) ? args.last : {}
       if back_options = options[:back]
-        url =
-          case back_options
-          when Array then polymorphic_path(back_options)
-          when true then :back
-          else back_options
-          end
-        if url
-          back_link = link_to content_tag(:i, nil, class: 'left arrow icon'), url, class: 'title-back-link'
-          title = back_link.safe_concat(title)
-        end
+        url = case back_options
+              when Array then polymorphic_path(back_options)
+              when true then :back
+              else back_options
+              end
+        back_link = link_to content_tag(:i, nil, class: 'left arrow icon'), url, class: 'title-back-link'
+        title = back_link.safe_concat(title)
       end
       title
     end
@@ -97,11 +107,11 @@ module GeoLabels
     def page_title_for_resource(args)
       options = args.extract_options!
       model = args[1].respond_to?(:model_name) ? args[1] : args[1].class
-      if args.first == :index
-        title = t('action.index.label', models: model.model_name.human_plural).html_safe
-      else
-        title = t("action.#{args.first}.label", model: model.model_name.human).html_safe
-      end
+      title = if args.first == :index
+                t('action.index.label', models: model.model_name.human_plural).html_safe
+              else
+                t("action.#{args.first}.label", model: model.model_name.human).html_safe
+              end
       if back_options = options[:back]
         url =
           case back_options
@@ -124,7 +134,7 @@ module GeoLabels
       "#{from_item} - #{to_item} / #{records.total_count}"
     end
 
-    def at(attribute_name, scope_model=nil)
+    def at(attribute_name, scope_model = nil)
       scope_model ||= @scope_model
       scope_model.human_attribute_name(attribute_name)
     end
@@ -133,9 +143,9 @@ module GeoLabels
     def search_row(options = {}, &blk)
       classes = Array.wrap(options[:class])
       classes |= ['search']
-      classes << 'conditions-present' if @q.conditions.present?
+      classes << 'conditions-present' if @q.base.conditions.any?
       content = capture(&blk)
-      content_tag(:tr, content,  class: classes )
+      content_tag(:tr, content, class: classes)
     end
 
     # This helper returns the link for showing a record inside a table
@@ -145,7 +155,11 @@ module GeoLabels
       else
         return unless can? :show, record
       end
-      link_to(content_tag(:i,nil, class: 'folder open icon'), path || record, class: 'table-link show ui mini basic primary icon button')
+      link_to(
+        content_tag(:i, nil, class: 'folder open icon'),
+        path || record,
+        class: 'table-link show ui mini basic primary icon button'
+      )
     end
 
     # This helper returns the link for showing a record inside a table
@@ -155,7 +169,11 @@ module GeoLabels
       else
         return unless can? :download, record
       end
-      link_to(content_tag(:i,nil, class: 'download icon'), path || [:download, record], class: 'table-link download ui mini violet icon button')
+      link_to(
+        content_tag(:i, nil, class: 'download icon'),
+        path || [:download, record],
+        class: 'table-link download ui mini violet icon button'
+      )
     end
 
     # This helper returns the link for editing a record inside a table
@@ -180,16 +198,27 @@ module GeoLabels
       record_name ||= record.name if record.respond_to?(:name)
       record_name ||= record.title if record.respond_to?(:title)
       confirm_text << " #{record_name}" if record_name.present?
-      confirm_text << "?"
-      link_to(content_tag(:i, nil, class: 'trash icon'), path || record, method: :delete, data: { confirm: confirm_text }, class: 'table-link destroy ui mini negative icon button')
+      confirm_text << '?'
+      link_to(
+        content_tag(:i, nil, class: 'trash icon'),
+        path || record,
+        method: :delete,
+        data: { confirm: confirm_text },
+        class: 'table-link destroy ui mini negative icon button'
+      )
+    end
+
+    def address_tag(address, title: nil)
+      tag.span('&nbsp;'.html_safe * 10) +
+        tag.div(address, class: 'ui basic tag label', title: title)
     end
 
     # https://coderwall.com/p/7gqmog/display-flash-messages-with-semantic-ui-in-rails
     def flash_class(level)
       case level.to_sym
-      when :success       then "ui positive message"
-      when :error, :alert then "ui negative message"
-      when :notice        then "ui info message"
+      when :success       then 'ui positive message'
+      when :error, :alert then 'ui negative message'
+      when :notice        then 'ui info message'
       else "ui #{level} message"
       end
     end

data/app/helpers/geo_labels/rating_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module GeoLabels
+  module RatingHelper
+    def show_rating_for(record, helper_topic)
+      tag.div class: 'rating-container item', data: {
+        topic: helper_topic,
+        record: record.class.name,
+        record_id: record.id,
+        rating: record.rating[helper_topic].value
+      } do
+        tag.span 'Hi theree'
+      end
+    end
+  end
+end

data/app/jobs/geo_labels/application_job.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GeoLabels
   class ApplicationJob < ActiveJob::Base
   end

data/app/mailers/geo_labels/application_mailer.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
 module GeoLabels
   class ApplicationMailer < ActionMailer::Base
-    default from: "from@example.com"
-    layout "mailer"
+
+    default from: 'from@example.com'
+    layout 'mailer'
   end
 end

data/app/models/concerns/geo_labels/ratings_support.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+require 'active_support/concern'
+
+module GeoLabels
+  # Represent the rating of one topic as an object
+  class RatingObject
+
+    attr_reader :record, :topic
+
+    def initialize(record, topic)
+      @record, @topic = record, topic
+    end
+
+    def value
+      # expect active_record column attribute
+      record.public_send("#{topic}_rating")
+    end
+
+    def value=(value)
+      record.public_send("#{topic}_rating=", value)
+    end
+  end
+
+  # Represent the possible rating objects for the topics as a list
+  class RatingList
+
+    class OutOfBoundIndex < StandardError
+    end
+
+    include Enumerable
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+    end
+
+    def each(&block)
+      if block_given?
+        object_list.each(&block)
+      else
+        to_enum(:each)
+      end
+    end
+
+    def object_list
+      record.class.rating_topics.map { |topic| RatingObject.new(record, topic) }
+    end
+
+    def [](index)
+      case index
+      when String then RatingObject.new(record, index.to_sym)
+      when Symbol then RatingObject.new(record, index)
+      when Integer
+        topic = record.class.rating_topics[index]
+        raise OutOfBoundIndex, 'Rating list index provided is out of bounds' unless topic
+
+        RatingObject.new(record, topic)
+      else
+        raise OutOfBoundIndex, 'Rating list index provided is out of bounds'
+      end
+    end
+
+    # allow short hand assign
+    #   record.rating[:food] = 3
+    def []=(topic, value)
+      self[topic].value = value
+    end
+  end
+
+  # Extend an ActiveRecord model with rating support
+  module RatingsSupport
+    extend ActiveSupport::Concern
+
+    included do
+      @rating_topics ||= {}
+    end
+
+    def rating(topic = nil)
+      if topic.present?
+        RatingObject.new(self, topic)
+      else
+        RatingList.new(self)
+      end
+    end
+
+    # nodoc
+    module ClassMethods
+      def has_rating_with_topic(topic, topic_options = {})
+        @rating_topics[topic] = topic_options
+        # TODO: check existance of integer field of "topic_#{rating}, default: 0"
+      end
+
+      def has_rating_with_topic?(topic)
+        @rating_topics.has_key?(topic)
+      end
+
+      def rating_topics
+        @rating_topics.keys
+      end
+    end
+  end
+end

data/app/models/geo_labels/application_record.rb

@@ -1,5 +1,27 @@
+# frozen_string_literal: true
+
 module GeoLabels
   class ApplicationRecord < ActiveRecord::Base
+
     self.abstract_class = true
+
+    RANSACKABLE_ATTRIBUTES = [].freeze
+    RANSACKABLE_ASSOCIATIONS = [].freeze
+
+    def self.ransackable_attributes(_auth_object = nil)
+      if const_defined? :RANSACKABLE_ATTRIBUTES
+        const_get :RANSACKABLE_ATTRIBUTES
+      else
+        RANSACKABLE_ATTRIBUTES
+      end
+    end
+
+    def self.ransackable_associations(_auth_object = nil)
+      if const_defined? :RANSACKABLE_ASSOCIATIONS
+        const_get :RANSACKABLE_ASSOCIATIONS
+      else
+        RANSACKABLE_ASSOCIATIONS
+      end
+    end
   end
 end

data/app/models/geo_labels/contact.rb

@@ -1,19 +1,44 @@
+# frozen_string_literal: true
+
 module GeoLabels
   class Contact < ApplicationRecord
+
     extend Geocoder::Model::ActiveRecord
+    include RatingsSupport
+
+    RANSACKABLE_ATTRIBUTES = %w[
+      city country created_at department description
+      id latitude longitude name state street
+      subsection updated_at
+    ].freeze
+    RANSACKABLE_ASSOCIATIONS = %w[contact_labels labels].freeze
+
+    STATE_OPTIONS = %w[approved recommended rejected].freeze
+
     has_many :contact_labels, dependent: :delete_all
     has_many :labels, through: :contact_labels
 
     geocoded_by :address
 
+    has_rating_with_topic :food
+
+    validates :name, presence: true
+    validates :state, inclusion: {in: STATE_OPTIONS}
+
     after_validation :geocode_if_necessary
 
-    def self.for_label_ids(label_ids, predication: 'and')
-      #predication = %w[and or].include?(predication) ? predication : 'and' #whitlelisting
+    def self.for_label_ids(label_ids, predication: 'and', states: ['approved'])
+      # predication = %w[and or].include?(predication) ? predication : 'and' #whitlelisting
       if predication == 'or'
-        joins(:labels).merge(Label.descendants_for_ids(label_ids)).distinct
+        labels = Label.find(label_ids)
+        labels_scope = labels.shift.self_and_descendants
+        labels.each do |label|
+          labels_scope = labels_scope.or(label.self_and_descendants)
+        end
+        # joins(:labels).merge(Label.descendants_for_ids(label_ids)).distinct
+        joins(:labels).merge(labels_scope).where(state: states).reorder('').distinct
       else
-        where id: ContactLabel.contact_ids_for_label_ids(label_ids)
+        where(id: ContactLabel.contact_ids_for_label_ids(label_ids), state: states)
       end
     end
 
@@ -22,43 +47,60 @@ module GeoLabels
     end
 
     def address
-      [street, city, state, country].map(&:presence).compact.join(', ')
+      [street, city, department, country].map(&:presence).compact.join(', ')
     end
 
     def address_changed?
-      street_changed? or city_changed? or state_changed? or country_changed?
+      street_changed? or city_changed? or department_changed? or country_changed?
     end
 
-    def full_name
-      [first_name, middle_name, last_name].map(&:presence).compact.join(' ')
+    STATE_OPTIONS.each do |option|
+      define_method "#{option}?" do
+        state == option
+      end
     end
 
-    ransacker :full_name do |parent|
-      Arel::Nodes::InfixOperation.new('||', Arel::Nodes::InfixOperation.new('||', parent.table[:first_name], parent.table[:middle_name]), parent.table[:last_name])
-    end
+    #def full_name
+    #  [first_name, middle_name, last_name].map(&:presence).compact.join(' ')
+    #end
+
+    #ransacker :full_name do |parent|
+    #  Arel::Nodes::InfixOperation.new(
+    #    '||',
+    #    Arel::Nodes::InfixOperation.new('||', parent.table[:first_name], parent.table[:middle_name]),
+    #    parent.table[:last_name]
+    #  )
+    #end
 
     def map_title
-      full_name
+      name
     end
 
     def map_attributes
       return {} unless geocoded?
+
       {
-        lat: latitude,
-        lng: longitude,
+        lat: latitude.try(:to_f),
+        lng: longitude.try(:to_f),
         title: map_title
       }
     end
 
     def geocode_if_necessary
       return if new_record? and latitude.present? and longitude.present?
-      if address_changed?
-        self.latitude = nil
-        self.longitude = nil
-        # Geocode addresses with at least 2 commas
-        geocode if address.count(',') > 1
-      end
+      return unless address_changed?
+
+      self.latitude = nil
+      self.longitude = nil
+      # Geocode addresses with at least 2 commas
+      geocode if address.count(',') > 1
     end
 
+    def lat_lng=(value)
+      case value
+      when String then self.latitude, self.longitude = value.split(/,\s?/)
+      when Array then self.latitude, self.longitude = value
+      end
+    end
   end
 end

data/app/models/geo_labels/contact_label.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
 module GeoLabels
   class ContactLabel < ApplicationRecord
+
     belongs_to :contact
     belongs_to :label
 
@@ -9,32 +11,66 @@ module GeoLabels
     # Sadly this stragegy fails when a contact has to labels assigned (Indonesian AND Vietnamese food), and
     # the query is for all food categories (parent).
     # Works for simple and concice situations. Not for multi label definitions
-    def self.contact_ids_for_label_ids2(label_ids)
+    def self.contact_ids_for_label_ids_old1(label_ids)
       label_ids = label_ids.to_s.split(',') unless label_ids.is_a?(Array)
-      scope = joins(:label).merge(Label.descendants_for_ids(label_ids)).select(:contact_id).group(:contact_id)
-      scope = scope.having(arel_table[:contact_id].count.eq label_ids.size).reorder('')
-      scope
+      label_ids_with_descendants = Label.descendants_for_ids(label_ids)
+      # scope = joins(:label).merge(label_ids_with_descendants).select(:contact_id).group(:contact_id)
+      joins(:label)
+        .merge(Label.where(id: label_ids_with_descendants.pluck(:id)))
+        .select(:contact_id)
+        .group(:contact_id)
+        .having(arel_table[:contact_id].count.eq label_ids.size)
+        .reorder('')
     end
 
     ### The strategy:
     # Create a subquery for each label collection possible situation
     # Then join all these subqueries on the contact_id to remain only
     # with the records having the contact_id in each of these subqueries
-    def self.contact_ids_for_label_ids(label_ids)
+    def self.contact_ids_for_label_ids_old2(label_ids)
       label_ids = label_ids.to_s.split(',') unless label_ids.is_a?(Array)
+      return none unless label_ids.any?
 
       records = Label.find(label_ids)
 
-      scope = joins(%|INNER JOIN "geo_labels_labels" ON "geo_labels_labels"."id" = "geo_labels_contact_labels"."label_id"|).merge(records.shift.self_and_descendants).reorder('').select(:contact_id)
+      scope = joins(%|INNER JOIN "geo_labels_labels" ON "geo_labels_labels"."id" = "geo_labels_contact_labels"."label_id"|)
+              .merge(records.shift.self_and_descendants)
+              .reorder('')
+              .select(:contact_id)
       records.each do |record|
         record_scope = joins(:label).merge(record.self_and_descendants).reorder('').select(:contact_id)
         join_table_name = "labeltable#{record.id}"
         join_table_contact_id = Arel::Nodes::SqlLiteral.new("#{join_table_name}.contact_id")
         query_str = %|INNER JOIN (#{record_scope.to_sql}) #{join_table_name} ON #{arel_table[:contact_id].eq(join_table_contact_id).to_sql}|
         scope = scope.joins(query_str)
-        #descendants_scope = descendants_scope.or(record.self_and_descendants)
+        # descendants_scope = descendants_scope.or(record.self_and_descendants)
       end
       scope
     end
+
+    ### The strategy predication AND:
+    # Create a query for all labels with descendents getting the contact ids to ruby
+    # Then find the overlapping ids [] & []
+    # Then find the resulting contacts
+    def self.contact_ids_for_label_ids(label_ids)
+      label_ids = label_ids.to_s.split(',') unless label_ids.is_a?(Array)
+      return [] unless label_ids.any?
+
+      found_contact_ids = nil
+      Label.find(label_ids).each do |label|
+        label_contact_ids = ContactLabel.where(label_id: label.self_and_descendants.pluck(:id)).pluck(:contact_id)
+        next found_contact_ids = label_contact_ids unless found_contact_ids
+
+        found_contact_ids = found_contact_ids.intersection(label_contact_ids)
+        #if found_contact_ids
+        #  # merge the overlapping ids
+        #  found_contact_ids = found_contact_ids.intersection(label_contact_ids)
+        #else
+        #  # initialize with found results
+        #  found_contact_ids = label_contact_ids
+        #end
+      end
+      found_contact_ids
+    end
   end
 end

data/app/models/geo_labels/label.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
 module GeoLabels
   class Label < ApplicationRecord
+    RANSACKABLE_ATTRIBUTES = %w[name].freeze
+
     has_many :contact_labels, dependent: :delete_all
+    has_many :contacts, through: :contact_labels
+
     acts_as_nested_set
 
+    validates :name, presence: true
+
     def self.descendants_for_ids(ids)
       records = find(ids)
       descendants_scope = records.shift.self_and_descendants
@@ -11,5 +19,10 @@ module GeoLabels
       end
       descendants_scope
     end
+
+    def associated_contacts
+      ids = ContactLabel.joins(:label).merge(self_and_descendants).pluck(:contact_id).uniq
+      Contact.order(:name).find(ids)
+    end
   end
 end

data/app/views/geo_labels/contacts/_form.html.slim

@@ -3,10 +3,7 @@
   .ui.top.attached.segment
     .field
       label= t 'form.name'
-      .three.fields
-        .field= f.text_field :first_name, placeholder: at(:first_name)
-        .field= f.text_field :middle_name, placeholder: at(:middle_name)
-        .field= f.text_field :last_name, placeholder: at(:last_name)
+      .field= f.text_field :name, placeholder: at(:name)
     .field
       label= t 'form.address'
       .two.fields
@@ -17,8 +14,8 @@
           label= at :city
           = f.text_field :city, placeholder: at(:city)
         .field
-          label= at :state
-          = f.text_field :state, placeholder: at(:state)
+          label= at :department
+          = f.text_field :department, placeholder: at(:department)
         .field
           label= at :country
           .ui.fluid.search.selection.dropdown
@@ -30,6 +27,25 @@
                 .item data-value=country.iso_short_name
                   i.flag class=country.alpha2.downcase
                   = country.iso_short_name
+    .field
+      label= at :state
+      .ui.fluid.selection.dropdown
+        = f.hidden_field :state
+        i.dropdown.icon
+        .default.text= at(:state)
+        .menu
+          - GeoLabels::Contact::STATE_OPTIONS.each do |option|
+            .item data-value=option = option
+    .field
+      label= at :description
+      = f.text_field :description
+    .field
+      .ui.compact.accordion
+        .title
+          i.dropdown.icon
+          => t('geo_labels.manual_lat_lng.title')
+          i.info.icon data-html=t('geo_labels.manual_lat_lng.explanation', default: 'missing translation geo_labels.manual_lat_lng.explanation') data-variation='wide'
+        .content= f.text_field :lat_lng
   .ui.attached.segment
     .ui.fluid.multiple.search.selection.dropdown
       = f.hidden_field :label_ids, value: @record.label_ids.join(',')