apidae 0.11.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 765dd17ae6901f726e634a675934148a79715022
-  data.tar.gz: bab182d1cc1367ed70b10dfda1bb1d3a08f0d47c
+  metadata.gz: '07291fb2c40fdbc091aff918c45c201602a5d58c'
+  data.tar.gz: 76f4566eb71404f129add27100872f1263ae868b
 SHA512:
-  metadata.gz: a019141cef8e85dc8806cd73c31dfbc02e5f95758c9be26825a7c8b647a4cb99ff2fd41af12723f8c867e9b52095d583ee195011dd5d8d2cf2de2c6d1775f5d1
-  data.tar.gz: 6695e5409d28e870ee3096db3737e88f3db3cc701ec5362860b8eab60c65ba45678ff20e6dbc780a9dc6db1c478a2c58baaf24d2a3eb1c6eff088738c52dde77
+  metadata.gz: fa72db3de71d37e56b2c8908d703419a72fc5f0efd2d9f03ce91233ae0d68bd402f4a49d775fa22856a2109f83c7bb8bb54593224cc1e14377f696afc2e6d811
+  data.tar.gz: e1a0c2c71710947ea1b47266e2bb995ba5a44cec98190b3358168e21681ce9b2da4d3c479932514620929da4758affe03cece6e8693cf2f4458e327af108f7a8

data/app/controllers/apidae/application_controller.rb

@@ -2,5 +2,24 @@ module Apidae
   class ApplicationController < ActionController::Base
     protect_from_forgery with: :exception
     before_action Rails.application.config.apidae_auth
+    before_action :check_user_data!
+
+    def apidae_user
+      send(Rails.application.config.apidae_user) if Rails.application.config.respond_to?(:apidae_user)
+    end
+
+    def user_is_admin?
+      apidae_user && Rails.application.config.respond_to?(:apidae_admin) && Rails.application.config.apidae_admin.call(apidae_user)
+    end
+
+    def user_has_data?
+      apidae_user && apidae_user.respond_to?(:apidae_projects_ids) && !apidae_user.apidae_projects_ids.blank?
+    end
+
+    def check_user_data!
+      unless user_has_data? || user_is_admin?
+        redirect_to main_app.root_path, alert: "Il n'y a aucun projet Apidae associé à votre compte."
+      end
+    end
   end
 end

data/app/controllers/apidae/dashboard_controller.rb

@@ -3,11 +3,20 @@ require_dependency "apidae/application_controller"
 module Apidae
   class DashboardController < ApplicationController
     def index
-      @objects = Obj.count
-      @selections = Selection.count
-      @projects = Project.count
+      if user_is_admin?
+        @objects = Obj.count
+        @selections = Selection.count
+        @projects = Project.count
+        @last_imports = FileImport.order(id: :desc).take(100)
+      else
+        projects = Project.where(apidae_id: apidae_user.apidae_projects_ids)
+        selections = Selection.where(apidae_project_id: projects.select(:id).map {|p| p.id})
+        @projects = projects.count
+        @selections = selections.uniq.count
+        @objects = SelectionObject.where(apidae_selection_id: selections.map {|s| s.id}.uniq).map {|so| so.apidae_object_id}.uniq.count
+        @last_imports = FileImport.where(apidae_id: apidae_user.apidae_projects_ids).order(id: :desc).take(100)
+      end
       @references = Reference.count
-      @last_imports = FileImport.order(id: :desc).take(100)
     end
   end
 end

data/app/controllers/apidae/objects_controller.rb

@@ -10,8 +10,13 @@ module Apidae
       if params[:selection_id]
         @selection = Selection.find(params[:selection_id])
         @objects = @selection.objects.select(:id, :apidae_id, :title_data, :apidae_type, :updated_at)
-      else
+      elsif user_is_admin?
         @objects = Obj.all.select(:id, :apidae_id, :title_data, :apidae_type, :updated_at)
+      else
+        projects_ids = Project.where(apidae_id: apidae_user.apidae_projects_ids).map {|p| p.id}
+        @objects = Obj.joins(:selections).where("apidae_selections.apidae_project_id IN (?)", projects_ids)
+                     .select("apidae_objs.id, apidae_objs.apidae_id, apidae_objs.title_data, apidae_objs.apidae_type, apidae_objs.updated_at")
+                     .distinct("apidae_objs.apidae_id").to_a
       end
     end
 

data/app/controllers/apidae/projects_controller.rb

@@ -5,7 +5,11 @@ module Apidae
     before_action :set_project, only: [:edit, :update, :destroy]
 
     def index
-      @projects = Project.all
+      if user_is_admin?
+        @projects = Project.all
+      else
+        @projects = Project.where(apidae_id: apidae_user.apidae_projects_ids)
+      end
     end
 
     def new

data/app/controllers/apidae/selections_controller.rb

@@ -5,7 +5,12 @@ module Apidae
     before_action :set_selection, only: [:show, :edit, :update, :destroy, :refresh]
 
     def index
-      @selections = Selection.all
+      if user_is_admin?
+        @selections = Selection.all
+      else
+        projects_ids = Project.where(apidae_id: apidae_user.apidae_projects_ids).map {|p| p.id}
+        @selections = Selection.where(apidae_project_id: projects_ids)
+      end
     end
 
     def show

data/app/helpers/apidae/application_helper.rb

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

data/app/models/apidae/apidae_data_parser.rb

@@ -0,0 +1,376 @@
+module Apidae
+  class ApidaeDataParser
+    PHONE = 201
+    EMAIL = 204
+    WEBSITE = 205
+
+    MODE_AUTO = 'auto'
+    MODE_MANUAL = 'manual'
+
+    MONDAY = 'MON'
+    TUESDAY = 'TUE'
+    WEDNESDAY = 'WED'
+    THURSDAY = 'THU'
+    FRIDAY = 'FRI'
+    SATURDAY = 'SAT'
+    SUNDAY = 'SUN'
+
+    ALL_DAYS  = [MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY]
+
+    WEEKDAYS_MAP = {
+        'LUNDI' => MONDAY,
+        'MARDI' => TUESDAY,
+        'MERCREDI' => WEDNESDAY,
+        'JEUD' => THURSDAY,
+        'VENDREDI' => FRIDAY,
+        'SAMEDI' => SATURDAY,
+        'DIMANCHE' => SUNDAY
+    }
+
+    def self.parse_versioned_fields(data_hash)
+      version_fields = data_hash[:champsAspect] || []
+      matched_fields = []
+      version_fields.each do |f|
+        case f
+        when 'nom'
+          matched_fields << 'title'
+        when 'presentation.descriptifCourt'
+          matched_fields << 'short_desc'
+        when 'presentation.descriptifDetaille'
+          matched_fields << 'long_desc'
+        when 'illustrations'
+          matched_fields << 'pictures'
+        when 'multimedias'
+          matched_fields << 'attachments'
+        when 'informations.moyensCommunication'
+          matched_fields << 'contact'
+        when 'descriptifsThematises'
+          matched_fields << 'theme_desc'
+        when 'ouverture.periodesOuvertures', 'ouverture.periodeEnClair'
+          matched_fields << 'openings_desc'
+          matched_fields << 'openings'
+        when 'ouverture.periodeEnClairAutomatique'
+          matched_fields << 'openings_desc_mode'
+        when 'descriptionTarif.tarifsEnClair', 'descriptionTarif.periodes'
+          matched_fields << 'rates_desc'
+          matched_fields << 'rates'
+        when 'descriptionTarif.tarifsEnClairAutomatique'
+          matched_fields << 'rates_desc_mode'
+        when 'prestations.equipements'
+          matched_fields << 'equipments'
+        when 'prestations.activites'
+          matched_fields << 'activities'
+        when 'prestations.services'
+          matched_fields << 'services'
+        when 'localisation.environnements'
+          matched_fields << 'environments'
+        when 'prestations.complementAccueil'
+          matched_fields << 'extra'
+        when 'localisation.geolocalisation.complement'
+          matched_fields << 'access'
+        else
+        end
+      end
+      matched_fields.uniq
+    end
+
+    def self.parse_title(data_hash, *locales)
+      {title: node_value(data_hash, :nom, *locales)}
+    end
+
+    def self.parse_owner_data(data_hash)
+      unless data_hash.blank?
+        {owner_name: data_hash[:nom], owner_id: data_hash[:id]}
+      end
+    end
+
+    def self.parse_desc_data(data_hash, private_data, *locales)
+      unless data_hash.blank?
+        {
+            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)]}]
+        }
+      end
+    end
+
+    def self.parse_pictures_data(pictures_array, *locales)
+      pics_data = {}
+      unless pictures_array.blank?
+        l = locales.blank? ? [DEFAULT_LOCALE] : locales
+        l.each do |locale|
+          pics_data[locale] = []
+          pictures_array.select { |p| p.is_a?(Hash) && !p[:traductionFichiers].blank? }.each do |pic|
+            pics_data[locale] << {
+                id: pic[:identifiant],
+                name: localized_value(pic, :nom, locale),
+                url: pic[:traductionFichiers][0][:url].gsub('http:', 'https:'),
+                description: localized_value(pic, :legende, locale),
+                credits: localized_value(pic, :copyright, locale),
+                expiration_date: pic[:dateLimiteDePublication]
+            }
+          end
+        end
+      end
+      {pictures: pics_data}
+    end
+
+    def self.parse_attachments_data(attachments_array, *locales)
+      atts_data = {}
+      unless attachments_array.blank?
+        l = locales.blank? ? [DEFAULT_LOCALE] : locales
+        l.each do |locale|
+          atts_data[locale] = []
+          attachments_array.select { |att| att.is_a?(Hash) && !att[:traductionFichiers].blank? }.each do |att|
+            atts_data[locale] << {
+                id: att[:identifiant],
+                name: localized_value(att, :nom, locale),
+                url: att[:traductionFichiers][0][:url].gsub('http:', 'https:'),
+                type: att[:type],
+                description: localized_value(att, :legende, locale)
+            }
+          end
+        end
+      end
+      {attachments: atts_data}
+    end
+
+    def self.parse_contact_data(information_hash, contacts_list)
+      contact_details = {contacts: contacts_list}
+      unless information_hash.blank?
+        contact_entries = information_hash[:moyensCommunication] || []
+        contact_entries.each do |c|
+          case c[:type][:id]
+          when PHONE
+            contact_details[:telephone] ||= []
+            contact_details[:telephone] << c[:coordonnees][:fr]
+          when EMAIL
+            contact_details[:email] ||= []
+            contact_details[:email] << c[:coordonnees][:fr]
+          when WEBSITE
+            contact_details[:website] ||= []
+            contact_details[:website] << c[:coordonnees][:fr]
+          else
+          end
+        end
+      end
+      contact_details
+    end
+
+    def self.parse_location_data(location_hash, type_data_hash, territories)
+      loc_data = {}
+      unless location_hash.blank?
+        address_hash = location_hash[:adresse]
+        computed_address = []
+        unless address_hash.blank?
+          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[: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[:access] = node_value(geoloc_details, :complement) if geoloc_details
+        loc_data[:environments] = location_hash[:environnements].map {|e| e[:id]} if location_hash[:environnements]
+      end
+      loc_data[:territories] = territories.map {|t| t[:id]} unless territories.blank?
+      loc_data
+    end
+
+    # Note : use internal format for openings storage (ideally Apihours one, to merge data from both sources)
+    def self.parse_openings(openings_hash, *locales)
+      if openings_hash && openings_hash[:periodeEnClair]
+        {
+            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),
+            time_periods: lists_ids(openings_hash[:indicationsPeriode])
+        }
+      end
+    end
+
+    def self.parse_rates(rates_hash, *locales)
+      if rates_hash
+        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)}
+        methods = rates_hash[:modesPaiement].blank? ? [] : rates_hash[:modesPaiement].map {|p| p[:id]}
+        {
+            rates_desc: desc, rates: values, payment_methods: methods,
+            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)
+        }
+      end
+    end
+
+    def self.parse_type_data(apidae_obj, type_hash, presta_hash, business_hash, *locales)
+      data_hash = type_hash || {}
+      prestations_hash = presta_hash || {}
+      apidae_obj.apidae_subtype = lists_ids(data_hash[:typesManifestation]).first if apidae_obj.apidae_type == Obj::FEM
+      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]),
+          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]),
+          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] : nil,
+          products: lists_ids(data_hash[:typesProduit], data_hash[:aopAocIgps], data_hash[:specialites]),
+          audience: lists_ids(prestations_hash[:typesClientele]),
+          animals: prestations_hash[:animauxAcceptes] == 'ACCEPTES',
+          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
+      }
+    end
+
+    def self.parse_service_data(data_hash, type_data_hash)
+      if data_hash
+        {
+            services: lists_ids(data_hash[:services]),
+            equipments: lists_ids(data_hash[:equipements]),
+            comfort: lists_ids(data_hash[:conforts]),
+            activities: lists_ids(data_hash[:activites], type_data_hash ? type_data_hash[:activites] : [],
+                                  type_data_hash ? type_data_hash[:activitesSportives] : [],
+                                  type_data_hash ? type_data_hash[:activitesCulturelles] : []),
+            challenged: lists_ids(data_hash[:tourismesAdaptes]),
+            languages: lists_ids(data_hash[:languesParlees])
+        }
+      end
+    end
+
+    def self.parse_tags_data(pres_data_hash, crit_data_hash, linked_data_hash)
+      tags = {}
+      if pres_data_hash
+        tags[:promo] = lists_ids(pres_data_hash[:typologiesPromoSitra])
+      end
+      unless crit_data_hash.blank?
+        tags[:internal] = crit_data_hash.map {|c| c[:id]}
+      end
+      unless linked_data_hash.blank? || linked_data_hash[:liensObjetsTouristiquesTypes].blank?
+        tags[:linked] = linked_data_hash[:liensObjetsTouristiquesTypes]
+                            .map {|l| {apidae_id: l[:objetTouristique][:id], apidae_type: l[:objetTouristique][:type], category: l[:type]}}
+      end
+      tags
+    end
+
+    def self.parse_booking(reservation_hash, *locales)
+      if reservation_hash
+        {
+            booking_desc: node_value(reservation_hash, :complement, *locales),
+            booking_entities: reservation_hash[:organismes]
+        }
+      end
+    end
+
+    def self.parse_town(location_hash)
+      if location_hash
+        address_hash = location_hash[:adresse]
+        (!address_hash.blank? && address_hash[:commune]) ? Town.find_by_apidae_id(address_hash[:commune][:id]) : nil
+      else
+        nil
+      end
+    end
+
+    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
+    end
+
+    def self.node_id(node, key)
+      node[key][:id] if node && node[key]
+    end
+
+    private
+
+    def self.build_rate(rate_period)
+      {
+          id: rate_period[:identifiant], start_date: rate_period[:dateDebut], end_date: rate_period[:dateFin],
+          values: rate_period[:tarifs].blank? ? [] : rate_period[:tarifs].map {|t| {min: t[:minimum], max: t[:maximum], type: t[:type][:id], details: node_value(t, :precisionTarif)}}
+      }
+    end
+
+    def self.build_openings(openings_data, *locales)
+      openings_list = openings_data[:periodesOuvertures]
+      closing_days = openings_data[:fermeturesExceptionnelles]
+      if openings_list.blank?
+        []
+      else
+        openings_list.map do |o|
+          {
+              id: o[:identifiant],
+              external_id: o[:identifiantTechnique],
+              start_date: o[:dateDebut],
+              end_date: o[:dateFin],
+              closing_days: closing_days.blank? ? [] : closing_days.map {|d| d[:dateSpeciale]},
+              details: node_value(o, :complementHoraire, *locales),
+              time_periods: [
+                  {
+                      type: 'opening',
+                      weekdays: compute_weekdays(o),
+                      time_frames: (o[:horaireOuverture].blank? && o[:horaireFermeture].blank?) ? [] : [{start_time: o[:horaireOuverture], end_time: o[:horaireFermeture], recurrence: nil}]
+                  }
+              ]
+          }
+        end
+      end
+    end
+
+    def self.compute_weekdays(opening_data)
+      if opening_data[:type] == 'OUVERTURE_TOUS_LES_JOURS'
+        ALL_DAYS
+      elsif opening_data[:type] == 'OUVERTURE_SAUF' && opening_data[:ouverturesJournalieres]
+        closed_weekdays = opening_data[:ouverturesJournalieres].map {|d| WEEKDAYS_MAP[d[:jour]]}
+        ALL_DAYS - closed_weekdays
+      elsif opening_data[:type] == 'OUVERTURE_SEMAINE' && opening_data[:ouverturesJournalieres]
+        opening_data[:ouverturesJournalieres].map {|d| WEEKDAYS_MAP[d[:jour]]}
+      else
+        []
+      end
+    end
+
+    def self.node_value(node, key, *locales)
+      l = locales.blank? ? [DEFAULT_LOCALE] : locales
+      locales_map = Hash[l.map {|loc| [localized_key(loc), loc]}]
+      if node && node[key]
+        node[key].slice(*locales_map.keys).transform_keys {|k| locales_map[k]}
+      else
+        {}
+      end
+    end
+
+    def self.localized_value(node, key, loc)
+      if node && node[key]
+        node[key][localized_key(loc)]
+      else
+        ''
+      end
+    end
+
+    def self.lists_ids(*lists)
+      lists.blank? ? [] : lists.map {|l| l.blank? ? [] : l.map {|elt| elt[:id]}}.flatten.uniq
+    end
+
+    def self.nodes_ids(*nodes)
+      nodes.blank? ? [] : nodes.select {|n| !n.blank?}.map {|n| n[:id]}
+    end
+
+    def self.localized_key(loc = DEFAULT_LOCALE)
+      "libelle#{loc.camelize.gsub('-', '')}".to_sym
+    end
+  end
+end