apidae 0.7.3 → 0.7.4

data/app/models/apidae/project.rb

@@ -1,5 +1,5 @@
-module Apidae
-  class Project < ActiveRecord::Base
-    has_many :apidae_selections, class_name: 'Apidae::Selection', foreign_key: :apidae_project_id
-  end
+module Apidae
+  class Project < ActiveRecord::Base
+    has_many :apidae_selections, class_name: 'Apidae::Selection', foreign_key: :apidae_project_id
+  end
 end

data/app/models/apidae/reference.rb

@@ -1,45 +1,45 @@
-module Apidae
-  class Reference < ApplicationRecord
-
-    INTERNAL = 'internal'
-
-    store_accessor :meta_data, :category, :parent
-
-    def self.import(refs_json)
-      refs_hashes = JSON.parse(refs_json, symbolize_names: true)
-      if refs_hashes.length != where("apidae_type != ?", INTERNAL).count
-        refs_hashes.each do |ref_data|
-          ref = Reference.find_or_initialize_by(apidae_id: ref_data[:id], apidae_type: ref_data[:elementReferenceType])
-          ref.label_data = ref_data.slice(:libelleFr, :libelleEn)
-          ref.parent = ref_data[:parent][:id] if ref_data[:parent]
-          ref.category = ref_data[:familleCritere] ? ref_data[:familleCritere][:id] : (ref_data[:typeLabel] ? ref_data[:typeLabel][:id] : nil)
-          ref.save!
-        end
-      end
-    end
-
-    def self.import_file(json_file)
-      refs_json = File.read(json_file)
-      import(refs_json)
-    end
-
-    def self.import_internal(internal_json)
-      refs_hashes = JSON.parse(internal_json, symbolize_names: true)
-      if refs_hashes.length != where(apidae_type: INTERNAL).count
-        refs_hashes.each do |ref_data|
-          ref = Reference.find_or_initialize_by(apidae_id: ref_data[:id], apidae_type: INTERNAL)
-          ref.label_data = {libelleFr: ref_data[:libelle]}
-          ref.save!
-        end
-      end
-    end
-
-    def label(language)
-      label_data["libelle#{language.to_s.upcase_first}"]
-    end
-
-    def detailed_label(language)
-      category ? "#{Reference.find_by_apidae_id(category).label(language)} - #{label(language)}" : label(language)
-    end
-  end
-end
+module Apidae
+  class Reference < ApplicationRecord
+
+    INTERNAL = 'internal'
+
+    store_accessor :meta_data, :category, :parent
+
+    def self.import(refs_json)
+      refs_hashes = JSON.parse(refs_json, symbolize_names: true)
+      if refs_hashes.length != where("apidae_type != ?", INTERNAL).count
+        refs_hashes.each do |ref_data|
+          ref = Reference.find_or_initialize_by(apidae_id: ref_data[:id], apidae_type: ref_data[:elementReferenceType])
+          ref.label_data = ref_data.slice(:libelleFr, :libelleEn)
+          ref.parent = ref_data[:parent][:id] if ref_data[:parent]
+          ref.category = ref_data[:familleCritere] ? ref_data[:familleCritere][:id] : (ref_data[:typeLabel] ? ref_data[:typeLabel][:id] : nil)
+          ref.save!
+        end
+      end
+    end
+
+    def self.import_file(json_file)
+      refs_json = File.read(json_file)
+      import(refs_json)
+    end
+
+    def self.import_internal(internal_json)
+      refs_hashes = JSON.parse(internal_json, symbolize_names: true)
+      if refs_hashes.length != where(apidae_type: INTERNAL).count
+        refs_hashes.each do |ref_data|
+          ref = Reference.find_or_initialize_by(apidae_id: ref_data[:id], apidae_type: INTERNAL)
+          ref.label_data = {libelleFr: ref_data[:libelle]}
+          ref.save!
+        end
+      end
+    end
+
+    def label(language)
+      label_data["libelle#{language.to_s.upcase_first}"]
+    end
+
+    def detailed_label(language)
+      category ? "#{Reference.find_by_apidae_id(category).label(language)} - #{label(language)}" : label(language)
+    end
+  end
+end

data/app/models/apidae/selection.rb

@@ -1,160 +1,160 @@
-require 'open-uri'
-
-module Apidae
-  class Selection < ActiveRecord::Base
-    has_many :apidae_selection_objects, class_name: 'Apidae::SelectionObject', foreign_key: :apidae_selection_id
-    has_many :objects, class_name: 'Apidae::Obj', source: :apidae_object, through: :apidae_selection_objects
-    belongs_to :apidae_project, optional: true, class_name: 'Apidae::Project', foreign_key: :apidae_project_id
-
-    AGENDA_ENDPOINT = 'agenda/detaille/list-identifiants'
-    SELECTION_ENDPOINT = 'recherche/list-identifiants'
-    MAX_COUNT = 100
-    MAX_LOOPS = 10
-
-    validates_presence_of :apidae_id, :reference
-    before_validation :generate_reference, on: :create
-
-    def self.add_or_update(selection_data, apidae_proj_id)
-      apidae_sel = Selection.where(apidae_id: selection_data[:id]).first_or_initialize
-      apidae_sel.label = selection_data[:nom]
-      apidae_sel.apidae_project_id = apidae_proj_id
-      apidae_sel.save!
-
-      # Note : should be done with basic collection assignment, but can't make it work...
-      current_objs = apidae_sel.objects.collect {|obj| obj.apidae_id}
-      imported_objs = selection_data[:objetsTouristiques].blank? ? [] : selection_data[:objetsTouristiques].collect {|obj| obj[:id]}
-
-      added = imported_objs - current_objs
-      removed = current_objs - imported_objs
-
-      added.each do |o|
-        obj = Obj.find_by_apidae_id(o)
-        SelectionObject.create(apidae_selection_id: apidae_sel.id, apidae_object_id: obj.id)
-      end
-
-      removed_ids = Obj.where(apidae_id: removed).map {|o| o.id}
-      SelectionObject.where(apidae_selection_id: apidae_sel.id, apidae_object_id: removed_ids).delete_all
-    end
-
-    def results(where_clause, offset, size)
-      objects.includes(:town).limit(size).offset(offset).where(where_clause)
-    end
-
-    def total(where_clause)
-      objects.where(where_clause).count
-    end
-
-    def api_results(opts = {})
-      key = cache_key(:results)
-      res = $apidae_cache.read(key)
-      unless res
-        query_args = build_args(SELECTION_ENDPOINT, opts.merge({selection_ids: [apidae_id]}))
-        res = query_api(query_args, true)
-        $apidae_cache.write(key, res)
-      end
-      res
-    end
-
-    def api_agenda(from, to)
-      key = cache_key(:agenda, from, to)
-      res = $apidae_cache.read(key)
-      unless res
-        query_args = build_args(AGENDA_ENDPOINT, {selection_ids: [apidae_id], from: from, to: to})
-        res = query_api(query_args, true)
-        $apidae_cache.write(key, res)
-      end
-      res
-    end
-
-    def as_text
-      "#{label} (#{apidae_id})"
-    end
-
-    private
-
-    def query_api(query_args, all_results = false)
-      query_result = {}
-
-      if all_results
-        loops = 0
-        query_args[:first] = 0
-        query_args[:count] = MAX_COUNT
-        response = JSON.parse get_response(query_args), symbolize_names: false
-        total = response['numFound']
-        query_result[:results] = response['objetTouristiqueIds'] || {}
-
-        while total > results_count(query_result) && loops < MAX_LOOPS
-          loops += 1
-          query_args[:first] += MAX_COUNT
-          response = JSON.parse get_response(query_args), symbolize_names: false
-          merge_results(response, query_result)
-        end
-        query_result[:count] = total
-      else
-        response = JSON.parse get_response(query_args), symbolize_names: false
-        query_result[:results] = response['objetTouristiqueIds'] || {}
-        query_result[:count] = response['numFound']
-      end
-      query_result
-    end
-
-    def results_count(result)
-      if result[:results] && result[:results].is_a?(Hash)
-        result[:results].values.flatten.length
-      else
-        result[:results].blank? ? 0 : result[:results].length
-      end
-    end
-
-    def get_response(args)
-      response = ''
-      query = JSON.generate args.except(:url)
-      logger.info "Apidae API query : #{args[:url]}?query=#{query}"
-      open("#{args[:url]}?query=#{CGI.escape query}") { |f|
-        f.each_line {|line| response += line if line}
-      }
-      response
-    end
-
-    def merge_results(response, result)
-      ids = response['objetTouristiqueIds']
-      unless ids.nil? || ids.empty?
-        if result[:results] && result[:results].is_a?(Hash)
-          first_day = ids.keys.first
-          if result[:results].has_key?(first_day)
-            result[:results][first_day] += ids[first_day]
-          else
-            result[:results][first_day] = ids[first_day]
-          end
-          result[:results].merge!(ids.except(first_day))
-        else
-          result[:results] += ids
-        end
-      end
-    end
-
-    def build_args(endpoint, opts = {})
-      {
-          url: "#{Rails.application.config.apidae_api_url}/#{endpoint}",
-          apiKey: apidae_project ? apidae_project.api_key : '',
-          projetId: apidae_project.apidae_id,
-          first: opts[:first] || 0,
-          count: opts[:count] || MAX_COUNT,
-          selectionIds: opts[:selection_ids],
-          dateDebut: opts[:from],
-          dateFin: opts[:to],
-          center: opts[:lat] && opts[:lng] ? {type: 'Point', coordinates: [opts[:lng], opts[:lat]]} : nil,
-          radius: opts[:radius] ? opts[:radius].to_i : nil,
-          responseFields: opts[:fields] || ['id']
-      }
-    end
-
-    def generate_reference
-      self.reference ||= (self.label.parameterize || self.apidae_id)
-    end
-
-    def cache_key(*args)
-      "#{apidae_id}_#{args.map {|a| a.to_s.parameterize}.join('_')}"
-    end
-  end
-end
+require 'open-uri'
+
+module Apidae
+  class Selection < ActiveRecord::Base
+    has_many :apidae_selection_objects, class_name: 'Apidae::SelectionObject', foreign_key: :apidae_selection_id
+    has_many :objects, class_name: 'Apidae::Obj', source: :apidae_object, through: :apidae_selection_objects
+    belongs_to :apidae_project, optional: true, class_name: 'Apidae::Project', foreign_key: :apidae_project_id
+
+    AGENDA_ENDPOINT = 'agenda/detaille/list-identifiants'
+    SELECTION_ENDPOINT = 'recherche/list-identifiants'
+    MAX_COUNT = 100
+    MAX_LOOPS = 10
+
+    validates_presence_of :apidae_id, :reference
+    before_validation :generate_reference, on: :create
+
+    def self.add_or_update(selection_data, apidae_proj_id)
+      apidae_sel = Selection.where(apidae_id: selection_data[:id]).first_or_initialize
+      apidae_sel.label = selection_data[:nom]
+      apidae_sel.apidae_project_id = apidae_proj_id
+      apidae_sel.save!
+
+      # Note : should be done with basic collection assignment, but can't make it work...
+      current_objs = apidae_sel.objects.collect {|obj| obj.apidae_id}
+      imported_objs = selection_data[:objetsTouristiques].blank? ? [] : selection_data[:objetsTouristiques].collect {|obj| obj[:id]}
+
+      added = imported_objs - current_objs
+      removed = current_objs - imported_objs
+
+      added.each do |o|
+        obj = Obj.find_by_apidae_id(o)
+        SelectionObject.create(apidae_selection_id: apidae_sel.id, apidae_object_id: obj.id)
+      end
+
+      removed_ids = Obj.where(apidae_id: removed).map {|o| o.id}
+      SelectionObject.where(apidae_selection_id: apidae_sel.id, apidae_object_id: removed_ids).delete_all
+    end
+
+    def results(where_clause, offset, size)
+      objects.includes(:town).limit(size).offset(offset).where(where_clause)
+    end
+
+    def total(where_clause)
+      objects.where(where_clause).count
+    end
+
+    def api_results(opts = {})
+      key = cache_key(:results)
+      res = $apidae_cache.read(key)
+      unless res
+        query_args = build_args(SELECTION_ENDPOINT, opts.merge({selection_ids: [apidae_id]}))
+        res = query_api(query_args, true)
+        $apidae_cache.write(key, res)
+      end
+      res
+    end
+
+    def api_agenda(from, to)
+      key = cache_key(:agenda, from, to)
+      res = $apidae_cache.read(key)
+      unless res
+        query_args = build_args(AGENDA_ENDPOINT, {selection_ids: [apidae_id], from: from, to: to})
+        res = query_api(query_args, true)
+        $apidae_cache.write(key, res)
+      end
+      res
+    end
+
+    def as_text
+      "#{label} (#{apidae_id})"
+    end
+
+    private
+
+    def query_api(query_args, all_results = false)
+      query_result = {}
+
+      if all_results
+        loops = 0
+        query_args[:first] = 0
+        query_args[:count] = MAX_COUNT
+        response = JSON.parse get_response(query_args), symbolize_names: false
+        total = response['numFound']
+        query_result[:results] = response['objetTouristiqueIds'] || {}
+
+        while total > results_count(query_result) && loops < MAX_LOOPS
+          loops += 1
+          query_args[:first] += MAX_COUNT
+          response = JSON.parse get_response(query_args), symbolize_names: false
+          merge_results(response, query_result)
+        end
+        query_result[:count] = total
+      else
+        response = JSON.parse get_response(query_args), symbolize_names: false
+        query_result[:results] = response['objetTouristiqueIds'] || {}
+        query_result[:count] = response['numFound']
+      end
+      query_result
+    end
+
+    def results_count(result)
+      if result[:results] && result[:results].is_a?(Hash)
+        result[:results].values.flatten.length
+      else
+        result[:results].blank? ? 0 : result[:results].length
+      end
+    end
+
+    def get_response(args)
+      response = ''
+      query = JSON.generate args.except(:url)
+      logger.info "Apidae API query : #{args[:url]}?query=#{query}"
+      open("#{args[:url]}?query=#{CGI.escape query}") { |f|
+        f.each_line {|line| response += line if line}
+      }
+      response
+    end
+
+    def merge_results(response, result)
+      ids = response['objetTouristiqueIds']
+      unless ids.nil? || ids.empty?
+        if result[:results] && result[:results].is_a?(Hash)
+          first_day = ids.keys.first
+          if result[:results].has_key?(first_day)
+            result[:results][first_day] += ids[first_day]
+          else
+            result[:results][first_day] = ids[first_day]
+          end
+          result[:results].merge!(ids.except(first_day))
+        else
+          result[:results] += ids
+        end
+      end
+    end
+
+    def build_args(endpoint, opts = {})
+      {
+          url: "#{Rails.application.config.apidae_api_url}/#{endpoint}",
+          apiKey: apidae_project ? apidae_project.api_key : '',
+          projetId: apidae_project.apidae_id,
+          first: opts[:first] || 0,
+          count: opts[:count] || MAX_COUNT,
+          selectionIds: opts[:selection_ids],
+          dateDebut: opts[:from],
+          dateFin: opts[:to],
+          center: opts[:lat] && opts[:lng] ? {type: 'Point', coordinates: [opts[:lng], opts[:lat]]} : nil,
+          radius: opts[:radius] ? opts[:radius].to_i : nil,
+          responseFields: opts[:fields] || ['id']
+      }
+    end
+
+    def generate_reference
+      self.reference ||= (self.label.parameterize || self.apidae_id)
+    end
+
+    def cache_key(*args)
+      "#{apidae_id}_#{args.map {|a| a.to_s.parameterize}.join('_')}"
+    end
+  end
+end

data/app/models/apidae/selection_object.rb

@@ -1,6 +1,6 @@
-module Apidae
-  class SelectionObject < ApplicationRecord
-    belongs_to :apidae_object, class_name: 'Apidae::Obj', foreign_key: :apidae_object_id
-    belongs_to :apidae_selection, class_name: 'Apidae::Selection', foreign_key: :apidae_selection_id
-  end
-end
+module Apidae
+  class SelectionObject < ApplicationRecord
+    belongs_to :apidae_object, class_name: 'Apidae::Obj', foreign_key: :apidae_object_id
+    belongs_to :apidae_selection, class_name: 'Apidae::Selection', foreign_key: :apidae_selection_id
+  end
+end

data/app/models/apidae/town.rb

@@ -1,27 +1,28 @@
-module Apidae
-  class Town < ActiveRecord::Base
-    def self.import(towns_json)
-      towns_hashes = JSON.parse(towns_json, symbolize_names: true)
-      if towns_hashes.length != count
-        countries = Hash[Reference.where(apidae_type: "Pays").map {|ref| [ref.apidae_id, ref.label(:fr)]}]
-        towns_hashes.each do |town_data|
-          town = Town.find_or_initialize_by(apidae_id: town_data[:id])
-          town.name = town_data[:nom]
-          town.postal_code = town_data[:codePostal]
-          town.insee_code = town_data[:code]
-          town.country = countries[town_data[:pays][:id]]
-          town.save!
-        end
-      end
-    end
-
-    def self.import_file(json_file)
-      towns_json = File.read(json_file)
-      import(towns_json)
-    end
-
-    def label
-      "#{name} (#{postal_code})"
-    end
-  end
-end
+module Apidae
+  class Town < ActiveRecord::Base
+    def self.import(towns_json)
+      towns_hashes = JSON.parse(towns_json, symbolize_names: true)
+      if towns_hashes.length != count
+        countries = Hash[Reference.where(apidae_type: "Pays").map {|ref| [ref.apidae_id, ref.label(:fr)]}]
+        towns_hashes.each do |town_data|
+          town = Town.find_or_initialize_by(apidae_id: town_data[:id])
+          town.name = town_data[:nom]
+          town.postal_code = town_data[:codePostal]
+          town.insee_code = town_data[:code]
+          town.country = countries[town_data[:pays][:id]]
+          town.description = town_data[:complement]
+          town.save!
+        end
+      end
+    end
+
+    def self.import_file(json_file)
+      towns_json = File.read(json_file)
+      import(towns_json)
+    end
+
+    def label
+      "#{name} (#{postal_code})"
+    end
+  end
+end