apidae 1.2.32 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 3fcd6ed7fe68248f1afd25dac542413aacf16dc7215d754a88eca43621d28ddd
-  data.tar.gz: cf90c2756612c64ed15082e8b3e8fc3b83f32c01d2647aa766f45e8cdf562c87
+SHA1:
+  metadata.gz: 11f5031e46f8bfa23ce228c242e023c4ebe10e0e
+  data.tar.gz: '0083f65ff4cfbd3f53c5a13126ca940c4be696ae'
 SHA512:
-  metadata.gz: 2be47f19c21d082da47bea33780d7d6e0e40636964901b566aa7e9d37bd68dfba14a39978f76a27b9a5ed94f6bbea932577c5f00f54d7a1e7accf27254dbe070
-  data.tar.gz: 5c015959607afd5f57c188b31934b635c0042d2f0e1ff52ff3fc471b70b79f3f78d8edf3edb89a9360757226c0741b8e36e450322c0e0991b0b101b7950a49b9
+  metadata.gz: 0a6544dae89ca3cee7525b37433fc6941b5ae76d720f2adce045d3357fd65efca3150885b0cb9da8234a5324218448e57545897865a77896e1bdfe7a462ab31b
+  data.tar.gz: 9c51ebdb6c1d9d671499fd60f086a8c43feb94a9c77d06108aa030b73d5bce00ad4fd5b58e0f5467d21a509bcc1594c2c59f6d19e4be2f61a78d76fc04037b3b

data/app/controllers/apidae/import_controller.rb

@@ -37,7 +37,7 @@ module Apidae
     def run
       success = true
       Export.pending.each do |e|
-        success &&= import_data(e)
+        success &&= e.import_data
       end
       success ? head(:ok) : head(:internal_server_error)
     end
@@ -48,7 +48,7 @@ module Apidae
 
     def create
       @export = Export.new(export_params)
-      if @export.save && import_data(@export)
+      if @export.save && @export.import_data
         redirect_to apidae.root_url, notice: 'Le fichier a bien été importé.'
       else
         flash.now[:alert] = "Une erreur s'est produite lors de l'import du fichier."
@@ -61,43 +61,5 @@ module Apidae
     def export_params
       params.require(:export).permit(:project_id, :file_url, :status)
     end
-
-    def import_data(e)
-      success = true
-      begin
-        open(e.file_url) do |f|
-          begin
-            FileImport.import(f, e.project_id)
-            unless e.confirm_url.blank?
-              uri = URI(e.confirm_url)
-              req = Net::HTTP::Post.new(uri)
-              Net::HTTP.start(uri.hostname, uri.port) do |http|
-                http.request(req)
-              end
-            end
-            e.update(status: Export::COMPLETE)
-            if Rails.application.config.respond_to?(:apidae_import_callback)
-              Rails.application.config.apidae_import_callback.call(e)
-            end
-          rescue Exception => ex
-            logger.error("Failed to import export file : #{e.file_url}")
-            logger.error("Error is : #{ex} \n#{ex.backtrace.join("\n") unless ex.backtrace.blank?}")
-            success = false
-            e.update(status: Export::CANCELLED)
-          end
-        end
-      rescue OpenURI::HTTPError => err
-        logger.error("Failed to download export file : #{e.file_url}")
-        logger.error("Error is : #{err}")
-        success = false
-        e.update(status: Export::CANCELLED)
-      rescue Exception => e
-        logger.error "Failed to import file : #{e.file_url}"
-        logger.error("Error is : #{err}")
-        success = false
-        e.update(status: Export::CANCELLED)
-      end
-      success
-    end
   end
 end

data/app/helpers/apidae/application_helper.rb

@@ -1,6 +1,6 @@
 module Apidae
   module ApplicationHelper
-    include Apidae::ApidaeHelper
+    include ApidaeHelper
 
     def apidae_user
       send(Rails.application.config.apidae_user) if Rails.application.config.respond_to?(:apidae_user)

data/app/models/apidae/apidae_data_parser.rb

@@ -44,7 +44,7 @@ module Apidae
         'LUNDI' => MONDAY,
         'MARDI' => TUESDAY,
         'MERCREDI' => WEDNESDAY,
-        'JEUDI' => THURSDAY,
+        'JEUD' => THURSDAY,
         'VENDREDI' => FRIDAY,
         'SAMEDI' => SATURDAY,
         'DIMANCHE' => SUNDAY
@@ -101,15 +101,10 @@ module Apidae
       {title: node_value(data_hash, :nom, *locales)}
     end
 
-    def self.parse_owner_data(data_hash, polls_data)
-      owner_data = {}
+    def self.parse_owner_data(data_hash)
       unless data_hash.blank?
-        owner_data.merge!({owner_name: data_hash[:nom], owner_id: data_hash[:id]})
+        {owner_name: data_hash[:nom], owner_id: data_hash[:id]}
       end
-      unless polls_data.blank?
-        owner_data.merge!({polls: polls_data[:enquetes] || []})
-      end
-      owner_data
     end
 
     def self.parse_desc_data(data_hash, private_data, *locales)
@@ -118,7 +113,7 @@ module Apidae
             short_desc: node_value(data_hash, :descriptifCourt, *locales),
             long_desc: node_value(data_hash, :descriptifDetaille, *locales),
             theme_desc: data_hash[:descriptifsThematises].blank? ? {} : Hash[data_hash[:descriptifsThematises].map {|th| [node_id(th, :theme), node_value(th, :description, *locales)]}],
-            private_desc: private_data.blank? ? {} : Hash[private_data.map {|d| [d[:nomTechnique], (node_value(d, :descriptif, *locales).blank? ? {LOCALE_FR => d[:libelleFr]} : node_value(d, :descriptif, *locales))]}]
+            private_desc: private_data.blank? ? {} : Hash[private_data.map {|d| [d[:nomTechnique], node_value(d, :descriptif, *locales)]}]
         }
       end
     end
@@ -156,7 +151,6 @@ module Apidae
                 name: localized_value(att, :nom, locale),
                 url: att[:traductionFichiers][0][:url].gsub('http:', 'https:'),
                 type: att[:type],
-                link: att[:link],
                 description: localized_value(att, :legende, locale)
             }
           end
@@ -214,22 +208,20 @@ module Apidae
     def self.parse_location_data(location_hash, type_data_hash, territories)
       loc_data = {}
       unless location_hash.blank?
-        address_hash = location_hash[:adresse] || {}
+        address_hash = location_hash[:adresse]
         computed_address = []
         unless address_hash.blank?
-          computed_address << address_hash[:adresse1]
-          computed_address << address_hash[:adresse2]
-          computed_address << address_hash[:adresse3]
+          computed_address << address_hash[:adresse1] unless address_hash[:adresse1].blank?
+          computed_address << address_hash[:adresse2] unless address_hash[:adresse2].blank?
+          computed_address << address_hash[:adresse3] unless address_hash[:adresse3].blank?
         end
         loc_data.merge!({address: computed_address})
-        loc_data.merge!({place: (type_data_hash ? type_data_hash[:nomLieu] : nil) || address_hash[:nomDuLieu]})
+        loc_data.merge!({place: type_data_hash[:nomLieu]}) if type_data_hash
         geoloc_details = location_hash[:geolocalisation]
         if geoloc_details && geoloc_details[:valide] && geoloc_details[:geoJson]
           loc_data[:latitude] = geoloc_details[:geoJson][:coordinates][1]
           loc_data[:longitude] = geoloc_details[:geoJson][:coordinates][0]
         end
-        loc_data[:map_reference] = geoloc_details[:reperePlan]
-        loc_data[:altitude] = geoloc_details[:altitude] if geoloc_details
         loc_data[:access] = node_value(geoloc_details, :complement) if geoloc_details
         loc_data[:environments] = location_hash[:environnements].map {|e| e[:id]} if location_hash[:environnements]
       end
@@ -244,7 +236,6 @@ module Apidae
             openings_desc: node_value(openings_hash, :periodeEnClair, *locales),
             openings_desc_mode: openings_hash[:periodeEnClairGenerationMode] == 'AUTOMATIQUE' ? MODE_AUTO : MODE_MANUAL,
             openings: build_openings(openings_hash, *locales),
-            all_year_long: openings_hash[:ouvertTouteLAnnee] == 'OUVERT_TOUTE_L_ANNEE' ? 'true' : 'false',
             time_periods: lists_ids(openings_hash[:indicationsPeriode]),
             openings_extra: lists_ids(openings_hash[:ouverturesComplementaires])
         }
@@ -256,10 +247,8 @@ module Apidae
         desc = rates_hash[:gratuit] ? {DEFAULT_LOCALE => 'gratuit'} : node_value(rates_hash, :tarifsEnClair, *locales)
         values = rates_hash[:periodes].blank? ? [] : rates_hash[:periodes].map {|p| build_rate(p, *locales)}
         methods = rates_hash[:modesPaiement].blank? ? [] : rates_hash[:modesPaiement].map {|p| p[:id]}
-
         {
             rates_desc: desc, rates: values, payment_methods: methods,
-            tax_included: rates_hash[:taxeDeSejourIncluse].blank? ? nil : (rates_hash[:taxeDeSejourIncluse] == 'OUI'),
             rates_desc_mode: rates_hash[:tarifsEnClairGenerationMode] == 'AUTOMATIQUE' ? MODE_AUTO : MODE_MANUAL,
             includes: node_value(rates_hash, :leTarifComprend, *locales),
             excludes: node_value(rates_hash, :leTarifNeComprendPas, *locales),
@@ -275,21 +264,18 @@ module Apidae
       apidae_obj.apidae_subtype = node_id(data_hash, :rubrique) if apidae_obj.apidae_type == Obj::EQU
       apidae_obj.apidae_subtype = lists_ids(data_hash[:typesHebergement]).first if apidae_obj.apidae_type == Obj::SPA
       {
-          categories: lists_ids(data_hash[:categories], data_hash[:typesDetailles], data_hash[:activiteCategories], data_hash[:typesHabitation]),
+          categories: lists_ids(data_hash[:categories], data_hash[:typesDetailles], data_hash[:activiteCategories]),
           themes: lists_ids(data_hash[:themes]),
           capacity: (data_hash[:capacite] || {})
                         .merge(presta_hash ? {group_min: presta_hash[:tailleGroupeMin], group_max: presta_hash[:tailleGroupeMax],
                                               age_min: presta_hash[:ageMin], age_max: presta_hash[:ageMax]} : {}),
           classification: nodes_ids(data_hash[:classement], data_hash[:classementPrefectoral], data_hash[:classification]) +
               lists_ids(data_hash[:classementsGuides]) + lists_ids(data_hash[:classements]),
-          classification_date: data_hash[:dateClassement],
-          classification_ref: data_hash[:numeroClassement],
           labels: lists_ids(data_hash[:labels], data_hash[:labelsChartesQualite], prestations_hash[:labelsTourismeHandicap]) +
               (node_id(data_hash, :typeLabel) ? [node_id(data_hash, :typeLabel)] : []),
           chains: lists_ids(data_hash[:chaines]) + nodes_ids(data_hash[:chaineEtLabel]),
           area: apidae_obj.apidae_type == Obj::DOS ? data_hash.except(:classification) : node_value(data_hash, :lieuDePratique),
-          track: apidae_obj.apidae_type == Obj::EQU ? (data_hash[:itineraire] || {}).except(:passagesDelicats) : nil,
-          tricky_sections: apidae_obj.apidae_type == Obj::EQU ? node_value(data_hash[:itineraire], :passagesDelicats, *locales) : nil,
+          track: apidae_obj.apidae_type == Obj::EQU ? data_hash[:itineraire] : nil,
           products: lists_ids(data_hash[:typesProduit], data_hash[:aopAocIgps], data_hash[:specialites]),
           audience: lists_ids(prestations_hash[:typesClientele]),
           animals: {allowed: prestations_hash[:animauxAcceptes] == 'ACCEPTES', desc: node_value(prestations_hash, :descriptifAnimauxAcceptes, *locales),
@@ -297,10 +283,7 @@ module Apidae
           extra: apidae_obj.apidae_type == Obj::SPA ? node_value(data_hash, :formuleHebergement, *locales) : node_value(prestations_hash, :complementAccueil, *locales),
           duration: apidae_obj.apidae_type == Obj::SPA ? {days: data_hash[:nombreJours], nights: data_hash[:nombreNuits]} : data_hash[:dureeSeance],
           certifications: data_hash[:agrements].blank? ? [] : data_hash[:agrements].map {|a| {id: a[:type][:id], identifier: a[:numero]}},
-          business: (business_hash || {}).except(:sallesEquipeesPour, :sallesEquipement, :sallesRestauration, :sallesReunion, :sallesHebergement),
-          business_equipments: lists_ids((business_hash || {})[:sallesEquipeesPour], (business_hash || {})[:sallesEquipement],
-                                         (business_hash || {})[:sallesRestauration], (business_hash || {})[:sallesHebergement]),
-          business_rooms: (business_hash || {})[:sallesReunion]
+          business: business_hash
       }
     end
 
@@ -334,19 +317,13 @@ module Apidae
       tags
     end
 
-    def self.parse_booking(reservation_hash, visits_hash, *locales)
-      booking_hash = {}
+    def self.parse_booking(reservation_hash, *locales)
       if reservation_hash
-        booking_hash[:booking_desc] = node_value(reservation_hash, :complement, *locales)
-        booking_hash[:booking_entities] = reservation_hash[:organismes]
-      end
-      if visits_hash
-        booking_hash[:visits_allowed] = visits_hash[:visitable] == true
-        booking_hash[:visits_desc] = node_value(visits_hash, :complementVisite, *locales)
-        booking_hash[:visits_duration] = visits_hash[:dureeMoyenneVisiteIndividuelle]
-        booking_hash[:visits_services] = lists_ids(visits_hash[:prestationsVisitesGroupees]) + lists_ids(visits_hash[:prestationsVisitesIndividuelles])
+        {
+            booking_desc: node_value(reservation_hash, :complement, *locales),
+            booking_entities: reservation_hash[:organismes]
+        }
       end
-      booking_hash
     end
 
     def self.parse_town(location_hash)
@@ -358,21 +335,10 @@ module Apidae
       end
     end
 
-    def self.parse_entity_fields(information_hash, type_data_hash, sp_hash)
-      entity_hash = {}
-      if information_hash
-        if information_hash[:structureGestion]
-          entity_hash.merge!({entity_id: information_hash[:structureGestion][:id], service_provider_id: node_id(type_data_hash, :prestataireActivites)})
-        end
-
-        if information_hash[:informationsLegales]
-          entity_hash.merge!({legal: information_hash[:informationsLegales]})
-        end
-      end
-      if sp_hash && sp_hash[:prestataireActivites]
-        entity_hash[:is_service_provider] = true
+    def self.parse_entity_fields(information_hash, type_data_hash)
+      if information_hash && information_hash[:structureGestion]
+        {entity_id: information_hash[:structureGestion][:id], service_provider_id: node_id(type_data_hash, :prestataireActivites)}
       end
-      entity_hash
     end
 
     def self.node_id(node, key)

data/app/models/apidae/export.rb

@@ -1,3 +1,6 @@
+require 'uri'
+require 'net/http'
+
 module Apidae
   class Export < ActiveRecord::Base
 
@@ -20,5 +23,43 @@ module Apidae
     def self.pending
       where(remote_status: 'SUCCESS', status: PENDING).order(:id)
     end
+
+    def import_data
+      success = true
+      begin
+        open(file_url) do |f|
+          begin
+            FileImport.import(f, project_id)
+            unless confirm_url.blank?
+              uri = URI(confirm_url)
+              req = Net::HTTP::Post.new(uri)
+              Net::HTTP.start(uri.hostname, uri.port) do |http|
+                http.request(req)
+              end
+            end
+            update(status: Export::COMPLETE)
+            if Rails.application.config.respond_to?(:apidae_import_callback)
+              Rails.application.config.apidae_import_callback.call(self)
+            end
+          rescue Exception => ex
+            logger.error("Failed to import export file : #{file_url}")
+            logger.error("Error is : #{ex} \n#{ex.backtrace.join("\n") unless ex.backtrace.blank?}")
+            success = false
+            update(status: Export::CANCELLED)
+          end
+        end
+      rescue OpenURI::HTTPError => err
+        logger.error("Failed to download export file : #{file_url}")
+        logger.error("Error is : #{err}")
+        success = false
+        update(status: Export::CANCELLED)
+      rescue Exception => e
+        logger.error "Failed to import file : #{e.file_url}"
+        logger.error("Error is : #{err}")
+        success = false
+        e.update(status: Export::CANCELLED)
+      end
+      success
+    end
   end
 end

data/app/models/apidae/file_import.rb

@@ -30,21 +30,18 @@ module Apidae
           Town.import(zfile.read(TOWNS_FILE))
           logger.info "Completed #{Town.count} towns update"
         end
-        ordered_files(zfile).each do |file|
+        zfile.each do |file|
           if file.file? && file.name.end_with?('.json')
             logger.info "Processing file : #{file.name}"
             if file.name.include?(MODIFIED_DIR)
               add_or_update_objects(zfile.read(file.name), result, project.locales, project.versions)
-            end
-            if file.name.include?(SELECTIONS_FILE)
-              add_or_update_selections(project, zfile.read(file.name), result)
-            end
-            if file.name.include?(DELETED_FILE)
+            elsif file.name.include?(DELETED_FILE)
               delete_objects(zfile.read(file.name), result)
+            elsif file.name.include?(SELECTIONS_FILE)
+              add_or_update_selections(project, zfile.read(file.name), result)
             end
           end
         end
-        project.cleanup_selections
         create(result.except(:selections)
                    .merge({remote_file: (zip_file.is_a?(File) ? zip_file.path : zip_file), status: STATUS_COMPLETE, apidae_id: project_id}))
         logger.info "Import results : #{result}"
@@ -107,16 +104,12 @@ module Apidae
       end
     end
 
-    def self.ordered_files(zfile)
-      zfile.sort_by {|f| f.name.include?(MODIFIED_DIR) ? 0 : (f.name.include?(SELECTIONS_FILE) ? 1 : 2)}
-    end
-
     def self.delete_objects(deleted_json, result)
       deleted_ids = JSON.parse(deleted_json)
       deleted_ids.each do |id|
         obj = Obj.find_by_apidae_id(id)
         if obj
-          obj.destroy! if obj.selections.empty?
+          obj.destroy!
           result[:deleted] += 1
         else
           logger.info "skipping object deletion : #{id}"
@@ -170,9 +163,7 @@ module Apidae
     def self.add_or_update_selections(project, selections_json, result)
       selections_hashes = JSON.parse(selections_json, symbolize_names: true)
       deleted_ids = Selection.where(apidae_project_id: project.id).collect {|sel| sel.apidae_id}.uniq - selections_hashes.collect {|sel| sel[:id]}
-      apidae_selection_ids = Selection.where(apidae_id: deleted_ids).map {|s| s.id}
-      SelectionObject.where(apidae_selection_id: apidae_selection_ids).delete_all
-      Selection.where(id: apidae_selection_ids).delete_all
+      Selection.where(apidae_id: deleted_ids).delete_all
       selections_hashes.each do |selection_data|
         logger.info "Updating selection #{selection_data[:id]}"
         Selection.add_or_update(selection_data, project.id)

data/app/models/apidae/obj.rb

@@ -7,24 +7,22 @@ module Apidae
 
     attr_accessor :locale
     attr_accessor :obj_version
-    attr_accessor :obj_versions
 
     store_accessor :title_data, :title
-    store_accessor :owner_data, :owner_name, :owner_id, :polls
+    store_accessor :owner_data, :owner_name, :owner_id
     store_accessor :description_data, :short_desc, :long_desc, :theme_desc, :private_desc
     store_accessor :pictures_data, :pictures
     store_accessor :attachments_data, :attachments
-    store_accessor :type_data, :categories, :themes, :capacity, :classification, :classification_date,
-                   :classification_ref, :labels, :chains, :area, :track, :tricky_sections, :products, :audience, :animals,
-                   :animals_desc, :extra, :duration, :certifications, :business, :business_equipments, :business_rooms
-    store_accessor :entity_data, :entity_id, :entity_name, :service_provider_id, :is_service_provider, :legal
+    store_accessor :type_data, :categories, :themes, :capacity, :classification, :labels, :chains, :area, :track,
+                   :products, :audience, :animals, :animals_desc, :extra, :duration, :certifications, :business
+    store_accessor :entity_data, :entity_id, :entity_name, :service_provider_id
     store_accessor :contact_data, :telephone, :email, :website, :google, :facebook, :twitter, :yelp, :trip_advisor, :fax,
                    :mobile_website, :shorty_url, :contacts
-    store_accessor :location_data, :address, :place, :latitude, :longitude, :access, :territories, :environments, :altitude, :map_reference
+    store_accessor :location_data, :address, :place, :latitude, :longitude, :access, :territories, :environments
     store_accessor :openings_data, :openings_desc, :openings_desc_mode, :openings, :time_periods, :openings_extra
-    store_accessor :rates_data, :rates_desc, :rates_desc_mode, :rates, :payment_methods, :includes, :excludes, :rates_extra, :tax_included
+    store_accessor :rates_data, :rates_desc, :rates_desc_mode, :rates, :payment_methods, :includes, :excludes, :rates_extra
     store_accessor :service_data, :services, :equipments, :comfort, :activities, :challenged, :languages
-    store_accessor :booking_data, :booking_desc, :booking_entities, :visits_allowed, :visits_desc, :visits_duration, :visits_services
+    store_accessor :booking_data, :booking_desc, :booking_entities
     store_accessor :tags_data, :promo, :internal, :linked
     store_accessor :version_data, :versioned_fields
 
@@ -85,7 +83,7 @@ module Apidae
         COS => {node: :informationsCommerceEtService, subtype: :commerceEtServiceType},
         DEG => {node: :informationsDegustation, subtype: :degustationType},
         DOS => {node: :informationsDomaineSkiable, subtype: :domaineSkiableType},
-        EQU => {node: :informationsEquipement, subtype: :rubrique},
+        EQU => {node: :informationsEquipement, subtype: :equipementType},
         FEM => {node: :informationsFeteEtManifestation, subtype: :feteEtManifestationType},
         HCO => {node: :informationsHebergementCollectif, subtype: :hebergementCollectifType},
         HLO => {node: :informationsHebergementLocatif, subtype: :hebergementLocatifType},
@@ -102,7 +100,6 @@ module Apidae
     after_initialize do
       @locale = DEFAULT_LOCALE
       @obj_version = DEFAULT_VERSION
-      @obj_versions = {}
     end
 
     def root_obj
@@ -114,15 +111,11 @@ module Apidae
     end
 
     def in_version(v)
-      if v == DEFAULT_VERSION && root_obj_id.nil?
-        @obj_version = DEFAULT_VERSION
-        self
-      else
-        if @obj_versions[v].nil?
-          @obj_versions[v] = versions.where(version: v).first
-      end
-        @obj_versions[v]
+      @cached_versions ||= {}
+      if @cached_versions[v].nil?
+        @cached_versions[v] = versions.where(version: v).first
       end
+      @cached_versions[v]
     end
 
     def in_locale(l)
@@ -171,11 +164,10 @@ module Apidae
       apidae_obj
     end
 
-    # Note : overrides existing fields (not a merge)
     def self.populate_fields(apidae_obj, object_data, locales)
       type_fields = TYPES_DATA[object_data[:type]]
       apidae_obj.last_update = DateTime.parse(object_data[:gestion][:dateModification]) unless object_data[:gestion].blank?
-      apidae_obj.owner_data = ApidaeDataParser.parse_owner_data(object_data[:gestion][:membreProprietaire], object_data[:enquete]) unless (object_data[:gestion].blank? && object_data[:enquete].blank?)
+      apidae_obj.owner_data = ApidaeDataParser.parse_owner_data(object_data[:gestion][:membreProprietaire]) unless object_data[:gestion].blank?
       apidae_obj.apidae_type = object_data[:type]
       apidae_obj.apidae_subtype = ApidaeDataParser.node_id(object_data[type_fields[:node]], type_fields[:subtype])
       apidae_obj.title_data = ApidaeDataParser.parse_title(object_data, *locales)
@@ -186,12 +178,12 @@ module Apidae
       apidae_obj.town = ApidaeDataParser.parse_town(object_data[:localisation])
       apidae_obj.openings_data = ApidaeDataParser.parse_openings(object_data[:ouverture], *locales)
       apidae_obj.rates_data = ApidaeDataParser.parse_rates(object_data[:descriptionTarif], *locales)
-      apidae_obj.booking_data = ApidaeDataParser.parse_booking(object_data[:reservation], object_data[:visites], *locales)
+      apidae_obj.booking_data = ApidaeDataParser.parse_booking(object_data[:reservation], *locales)
       apidae_obj.type_data = ApidaeDataParser.parse_type_data(apidae_obj, object_data[type_fields[:node]], object_data[:prestations],
                                              object_data[:tourismeAffaires], *locales)
       apidae_obj.pictures_data = ApidaeDataParser.parse_pictures_data(object_data[:illustrations], *locales)
       apidae_obj.attachments_data = ApidaeDataParser.parse_attachments_data(object_data[:multimedias], *locales)
-      apidae_obj.entity_data = ApidaeDataParser.parse_entity_fields(object_data[:informations], object_data[type_fields[:node]], object_data[:informationsPrestataireActivites])
+      apidae_obj.entity_data = ApidaeDataParser.parse_entity_fields(object_data[:informations], object_data[type_fields[:node]])
       apidae_obj.service_data = ApidaeDataParser.parse_service_data(object_data[:prestations], object_data[type_fields[:node]])
       apidae_obj.tags_data = ApidaeDataParser.parse_tags_data(object_data[:presentation], object_data[:criteresInternes], object_data[:liens])
       apidae_obj.meta_data = object_data[:metadonnees]

data/app/models/apidae/project.rb

@@ -20,11 +20,5 @@ module Apidae
     def versions=(values)
       self.versions_data = values.blank? ? nil : values.join('|')
     end
-
-    def cleanup_selections
-      apidae_selections.reload.each do |s|
-        s.cleanup
-      end
-    end
   end
 end

data/app/models/apidae/reference.rb

@@ -10,7 +10,7 @@ module Apidae
     end
 
     def self.import(refs_json)
-      locales = Rails.application.config.respond_to?(:apidae_locales) ? Rails.application.config.apidae_locales : [DEFAULT_LOCALE]
+    locales = Rails.application.config.respond_to?(:apidae_locales) ? Rails.application.config.apidae_locales : [DEFAULT_LOCALE]
       locales_map = Hash[locales.map {|loc| ["libelle#{loc.camelize.gsub('-', '')}".to_sym, loc]}]
       refs_hashes = JSON.parse(refs_json, symbolize_names: true)
       if refs_hashes.length != where("apidae_type != ?", INTERNAL).count

data/app/models/apidae/selection.rb

@@ -42,20 +42,6 @@ module Apidae
       SelectionObject.where(apidae_selection_id: apidae_sel.id, apidae_object_id: removed_ids).delete_all
     end
 
-    def cleanup
-      obsolete_count = apidae_selection_objects
-        .joins("LEFT JOIN apidae_objs ON apidae_objs.id = apidae_selection_objects.apidae_object_id")
-        .where("apidae_objs.id IS NULL")
-        .delete_all
-      logger.info "Cleaned up #{obsolete_count} obsolete selection-objects associations for selection #{apidae_id}"
-
-      dups = apidae_selection_objects.reload.group(:apidae_object_id)
-                                     .select("COUNT(id), apidae_object_id, ARRAY_AGG(id) AS so_ids")
-                                     .having("COUNT(id) > ?", 1).map {|so| so.so_ids}
-      dups_count = apidae_selection_objects.where(id: dups.map {|d| d.sort[1..-1]}.flatten).delete_all
-      logger.info "Cleaned up #{dups_count} duplicate selection-objects associations for selection #{apidae_id}"
-    end
-
     def results(where_clause, offset, size)
       objects.includes(:town).limit(size).offset(offset).where(where_clause)
     end
@@ -106,7 +92,6 @@ module Apidae
       query_api(query_args, true, false)
     end
 
-    # Note : WARNING - updated obj will only contain the provided fields
     def add_or_refresh_obj(apidae_obj_id, fields = ["@all"])
       if valid_api?
         res = api_object(apidae_obj_id, fields)
@@ -117,7 +102,6 @@ module Apidae
       end
     end
 
-    # Note : WARNING - updated objs will only contain the provided fields
     def add_or_refresh_objs(fields = ["@all"])
       if valid_api?
         res = api_objects({fields: fields})
@@ -219,7 +203,7 @@ module Apidae
     def get_response(args)
       response = ''
       query = JSON.generate args.except(:url)
-      logger.debug "Apidae API query : #{args[:url]}?query=#{query}"
+      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}
       }

data/config/initializers/constants.rb

@@ -8,10 +8,9 @@ module Apidae
   LOCALE_ZH = 'zh'
   LOCALE_ES = 'es'
   LOCALE_PT_BR = 'pt-BR'
-  LOCALE_JP = 'jp'
 
   DEFAULT_LOCALE = LOCALE_FR
-  ALL_LOCALES = [LOCALE_FR, LOCALE_EN, LOCALE_IT, LOCALE_DE, LOCALE_NL, LOCALE_RU, LOCALE_ZH, LOCALE_ES, LOCALE_PT_BR, LOCALE_JP]
+  ALL_LOCALES = [LOCALE_FR, LOCALE_EN, LOCALE_IT, LOCALE_DE, LOCALE_NL, LOCALE_RU, LOCALE_ZH, LOCALE_ES, LOCALE_PT_BR]
 
   STANDARD_VERSION = 'STANDARD'
   WINTER_VERSION = 'HIVER'
@@ -25,11 +24,8 @@ module Apidae
   ALL_VERSIONS = [STANDARD_VERSION, WINTER_VERSION, SUMMER_VERSION, CHALLENGED_VERSION, BUSINESS_VERSION,
                   GROUPS_VERSION, ACTIVITIES_VERSION]
 
-  LOCALIZED_FIELDS = [:title, :short_desc, :long_desc, :pictures, :attachments,
-                      :openings_desc, :rates_desc, :includes, :excludes, :extra, :booking_desc]
-  ALL_FIELDS = LOCALIZED_FIELDS + [:theme_desc, :private_desc, :capacity, :telephone, :email, :website,
-                                   :google, :facebook, :twitter, :yelp, :trip_advisor, :fax, :mobile_website, :shorty_url,
-                                   :openings, :openings_extra, :rates, :services, :payment_methods, :categories, :themes,
-                                   :labels, :chains, :classification, :challenged, :environments, :languages, :products,
-                                   :animals, :equipments, :comfort, :activities, :promo, :internal, :linked]
+  LOCALIZED_FIELDS = [:title, :short_desc, :long_desc, :pictures, :attachments, :openings_desc, :rates_desc,
+                      :includes, :excludes, :extra, :booking_desc]
+  ALL_FIELDS = LOCALIZED_FIELDS + [:theme_desc, :private_desc, :capacity, :telephone, :email, :website, :services,
+                                   :equipments, :comfort, :activities, :promo, :internal, :linked]
 end

data/config/locales/apidae.fr.yml

@@ -41,7 +41,6 @@ fr:
       ru: Russe
       zh: Chinois
       'pt-BR': Brésilien
-      jp: Japonais
     versions:
       STANDARD: Standard
       HIVER: Hiver

data/lib/apidae/version.rb

@@ -1,3 +1,3 @@
 module Apidae
-  VERSION = "1.2.32"
+  VERSION = "1.3.0"
 end

data/test/dummy/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 2020_05_28_101957) do
+ActiveRecord::Schema.define(version: 2020_05_22_124205) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -92,10 +92,8 @@ ActiveRecord::Schema.define(version: 2020_05_28_101957) do
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.jsonb "meta_data"
-    t.boolean "is_active"
     t.index ["apidae_id"], name: "index_apidae_references_on_apidae_id"
     t.index ["apidae_type"], name: "index_apidae_references_on_apidae_type"
-    t.index ["is_active"], name: "index_apidae_references_on_is_active"
   end
 
   create_table "apidae_selection_objects", force: :cascade do |t|