apidae 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 63b211aee25599748e88d29aac6ce145b432b307
+  data.tar.gz: dd74e76a618885e9dbc6306fbe2b96c0db6b15ee
+SHA512:
+  metadata.gz: b877a7868af4dee3939ae6e1faabeb881a30abaf9a0a1e71f3d4b42e50656e9c2cba7a0b471f09806bafb81a131f5cddb32107b75108357ba52cecf04803f68c
+  data.tar.gz: d2c6fb144801f332f1e5b2dac5f100aa6a8cc80c0174146fcc3d2ec799e368655dfc2e2a7b3af2ba511a3a4d6be98d8c54805f673453bd7d5726e093fa73f746

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Jean-Baptiste Vilain
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Apidae Engine Rails
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Apidae'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/apidae/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/apidae/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/apidae/application_controller.rb

@@ -0,0 +1,5 @@
+module Apidae
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/apidae/objects_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "apidae/application_controller"
+
+module Apidae
+  class ObjectsController < ApplicationController
+    before_action :set_object, only: [:show, :edit, :update, :destroy]
+
+    # GET /objects
+    def index
+      @objects = Object.all
+    end
+
+    # GET /objects/1
+    def show
+    end
+
+    # GET /objects/new
+    def new
+      @object = Object.new
+    end
+
+    # GET /objects/1/edit
+    def edit
+    end
+
+    # POST /objects
+    def create
+      @object = Object.new(object_params)
+
+      if @object.save
+        redirect_to @object, notice: 'Object was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /objects/1
+    def update
+      if @object.update(object_params)
+        redirect_to @object, notice: 'Object was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /objects/1
+    def destroy
+      @object.destroy
+      redirect_to objects_url, notice: 'Object was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_object
+        @object = Object.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def object_params
+        params.require(:object).permit(:address, :apidae_id, :apidae_type, :apidae_subtype, :title, :short_desc, :contact, :long_desc, :type_data, :latitude, :longitude, :openings, :rates, :reservation)
+      end
+  end
+end

data/app/controllers/apidae/selections_controller.rb

@@ -0,0 +1,62 @@
+require_dependency "apidae/application_controller"
+
+module Apidae
+  class SelectionsController < ApplicationController
+    before_action :set_selection, only: [:show, :edit, :update, :destroy]
+
+    # GET /selections
+    def index
+      @selections = Selection.all
+    end
+
+    # GET /selections/1
+    def show
+    end
+
+    # GET /selections/new
+    def new
+      @selection = Selection.new
+    end
+
+    # GET /selections/1/edit
+    def edit
+    end
+
+    # POST /selections
+    def create
+      @selection = Selection.new(selection_params)
+
+      if @selection.save
+        redirect_to @selection, notice: 'Selection was successfully created.'
+      else
+        render :new
+      end
+    end
+
+    # PATCH/PUT /selections/1
+    def update
+      if @selection.update(selection_params)
+        redirect_to @selection, notice: 'Selection was successfully updated.'
+      else
+        render :edit
+      end
+    end
+
+    # DELETE /selections/1
+    def destroy
+      @selection.destroy
+      redirect_to selections_url, notice: 'Selection was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_selection
+        @selection = Selection.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def selection_params
+        params.require(:selection).permit(:label, :reference, :apidae_id)
+      end
+  end
+end

data/app/helpers/apidae/application_helper.rb

@@ -0,0 +1,4 @@
+module Apidae
+  module ApplicationHelper
+  end
+end

data/app/helpers/apidae/objects_helper.rb

@@ -0,0 +1,4 @@
+module Apidae
+  module ObjectsHelper
+  end
+end

data/app/helpers/apidae/selections_helper.rb

@@ -0,0 +1,4 @@
+module Apidae
+  module SelectionsHelper
+  end
+end

data/app/models/apidae/attached_file.rb

@@ -0,0 +1,31 @@
+module Apidae
+  class AttachedFile < ActiveRecord::Base
+    belongs_to :apidae_object, :class_name => 'Apidae::Object'
+
+    has_attached_file :picture,
+                      {
+                          :styles => {
+                              :xlarge => ['1600x1200>', :jpg],
+                              :large => ['1280x960>', :jpg],
+                              :medium => ['800x600>', :jpg],
+                              :small => ['320x240', :jpg],
+                              :thumb => ['200x200>', :png]
+                          },
+                          :default_url => "/#{Rails.application.config.apidae_pictures_path}/default/logo.png",
+                          :path => "public/#{Rails.application.config.apidae_pictures_path}/:apidae_type/:apidae_id/:basename.:extension",
+                          :url => "/#{Rails.application.config.apidae_pictures_path}/:apidae_type/:apidae_id/:basename.:extension"
+                      }
+
+    validates_attachment :picture, content_type: { content_type: /\Aimage\/.*\Z/ }
+
+    private
+
+    Paperclip.interpolates :apidae_type do |attachment, style|
+      attachment.instance.apidae_object.apidae_type.downcase
+    end
+
+    Paperclip.interpolates :apidae_id do |attachment, style|
+      attachment.instance.apidae_object.apidae_id
+    end
+  end
+end

data/app/models/apidae/object.rb

@@ -0,0 +1,217 @@
+module Apidae
+  class Object < ActiveRecord::Base
+
+    belongs_to :town, :class_name => 'Apidae::Town', foreign_key: :town_insee_code, primary_key: :insee_code
+    has_many :attached_files, :class_name => 'Apidae::AttachedFile'
+    has_and_belongs_to_many :selections, :class_name => 'Apidae::Selection'
+
+    store :pictures_data, accessors: [:pictures], coder: JSON
+    store :type_data, accessors: [:categories, :themes], coder: JSON
+    store :contact, accessors: [:telephone, :email, :website], coder: JSON
+    store :address, accessors: [:address_fields], coder: JSON
+    store :openings, accessors: [:description, :opening_periods], coder: JSON
+
+    TYPES_DATA = {
+        'ACTIVITE' => {node: :informationsActivite, subtype: :activiteType},
+        'COMMERCE_ET_SERVICE' => {node: :informationsCommerceEtService, subtype: :commerceEtServiceType},
+        'DEGUSTATION' => {node: :informationsDegustation, subtype: :degustationType},
+        'DOMAINE_SKIABLE' => {node: :informationsDomaineSkiable, subtype: :domaineSkiableType},
+        'EQUIPEMENT' => {node: :informationsEquipement, subtype: :equipementType},
+        'FETE_ET_MANIFESTATION' => {node: :informationsFeteEtManifestation, subtype: :feteEtManifestationType},
+        'HEBERGEMENT_COLLECTIF' => {node: :informationsHebergementCollectif, subtype: :hebergementCollectifType},
+        'HEBERGEMENT_LOCATIF' => {node: :informationsHebergementLocatif, subtype: :hebergementLocatifType},
+        'HOTELLERIE' => {node: :informationsHotellerie, subtype: :hotellerieType},
+        'HOTELLERIE_PLEIN_AIR' => {node: :informationsHotelleriePleinAir, subtype: :hotelleriePleinAirType},
+        'PATRIMOINE_CULTUREL' => {node: :informationsPatrimoineCulturel, subtype: :patrimoineCulturelType},
+        'PATRIMOINE_NATUREL' => {node: :informationsPatrimoineNaturel, subtype: :patrimoineNaturelType},
+        'RESTAURATION' => {node: :informationsRestauration, subtype: :restaurationType},
+        'SEJOUR_PACKAGE' => {node: :informationsSejourPackage, subtype: :sejourPackageType},
+        'STRUCTURE' => {node: :informationsStructure, subtype: :structureType},
+        'TERRITOIRE' => {node: :informationsTerritoire, subtype: :territoireType}
+    }
+
+    PHONE = 201
+    EMAIL = 204
+    WEBSITE = 205
+
+
+    def self.import(json_dir)
+      result = false
+      if Dir.exist?(json_dir)
+        Dir.foreach(json_dir) do |f|
+          if f.end_with?('.json')
+            json_file = File.join(json_dir, f)
+            objects_json = File.read(json_file)
+            objects_hashes = JSON.parse(objects_json, symbolize_names: true)
+            objects_hashes.each do |object_data|
+              type_fields = TYPES_DATA[object_data[:type]]
+              existing_obj = Apidae::Object.find_by_apidae_id(object_data[:id])
+              unless existing_obj
+                Apidae::Object.create!(
+                    apidae_id: object_data[:id],
+                    apidae_type: object_data[:type],
+                    apidae_subtype: node_value(object_data[type_fields[:node]], object_data[type_fields[:subtype]]),
+                    title: node_value(object_data, :nom),
+                    short_desc: node_value(object_data[:presentation], :descriptifCourt),
+                    long_desc: node_value(object_data[:presentation], :descriptifDetaille),
+                    contact: contact(object_data[:informations]),
+                    address: address(object_data[:localisation][:adresse]),
+                    town: town(object_data[:localisation][:adresse]),
+                    latitude: latitude(object_data[:localisation]),
+                    longitude: longitude(object_data[:localisation]),
+                    openings: openings(object_data[:ouverture]),
+                    rates: rates(object_data[:descriptionTarif]),
+                    reservation: reservation(object_data[:reservation]),
+                    type_data: object_data[type_fields[:node]],
+                    pictures_data: pictures_urls(object_data[:illustrations])
+                )
+              end
+            end
+          end
+          result = true
+        end
+        result
+      end
+    end
+
+    def self.update_fields(json_dir)
+      result = false
+      if Dir.exist?(json_dir)
+        Dir.foreach(json_dir) do |f|
+          if f.end_with?('.json')
+            json_file = File.join(json_dir, f)
+            objects_json = File.read(json_file)
+            objects_hashes = JSON.parse(objects_json, symbolize_names: true)
+            objects_hashes.each do |object_data|
+              obj = Apidae::Object.find_by_apidae_id(object_data[:id])
+              if obj
+                yield(obj, object_data)
+                obj.save!
+              end
+            end
+          end
+          result = true
+        end
+        result
+      end
+    end
+
+    def self.load_pictures
+      Object.all.each do |obj|
+        if obj.apidae_attached_files.blank? && obj.pictures.any?
+          obj.pictures.each do |pic|
+            begin
+              attached = AttachedFile.new(apidae_object_id: id, name: pic[:name], picture: URI.parse(pic[:url]),
+                                          description: pic[:description], credits: pic[:credits])
+              attached.save
+            rescue OpenURI::HTTPError => e
+              puts "Could not retrieve attached picture for object #{title} - Error is #{e.message}"
+            end
+          end
+        end
+      end
+    end
+
+    def self.pictures_urls(pictures_array)
+      pics_data = []
+      unless pictures_array.blank?
+        pictures_array.select { |p| p.is_a?(Hash) && !p[:traductionFichiers].blank? }.each do |pic|
+          pics_data << {
+              name: node_value(pic, :nom),
+              url: pic[:traductionFichiers][0][:url],
+              description: node_value(pic, :legende),
+              credits: node_value(pic, :copyright)
+          }
+        end
+      end
+      {pictures: pics_data}
+    end
+
+    def self.contact(information_hash)
+      contact_details = {}
+      contact_entries = information_hash[:moyensCommunication].nil? ? [] : information_hash[:moyensCommunication]
+      contact_entries.each do |c|
+        case c[:type][:id]
+          when PHONE
+            contact_details[:telephone] = c[:coordonnees][:fr]
+          when EMAIL
+            contact_details[:email] = c[:coordonnees][:fr]
+          when WEBSITE
+            contact_details[:website] = c[:coordonnees][:fr]
+          else
+        end
+      end
+      contact_details
+    end
+
+    def self.address(address_hash)
+      computed_address = []
+      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?
+      {address_fields: computed_address}
+    end
+
+    def self.town(address_hash)
+      address_hash[:commune] ? Town.find_by_apidae_id(address_hash[:commune][:id]) : nil
+    end
+
+    def self.latitude(location_hash)
+      geoloc_details = location_hash[:geolocalisation]
+      (geoloc_details && geoloc_details[:valide] && geoloc_details[:geoJson]) ? geoloc_details[:geoJson][:coordinates][1] : nil
+    end
+
+    def self.longitude(location_hash)
+      geoloc_details = location_hash[:geolocalisation]
+      (geoloc_details && geoloc_details[:valide] && geoloc_details[:geoJson]) ? geoloc_details[:geoJson][:coordinates][0] : nil
+    end
+
+    def self.openings(openings_hash)
+      if openings_hash && openings_hash[:periodeEnClair]
+        {description: openings_hash[:periodeEnClair][:libelleFr], opening_periods: openings_hash[:periodesOuvertures]}
+      end
+    end
+
+    def self.rates(rates_hash)
+      if rates_hash
+        if rates_hash[:gratuit]
+          return 'gratuit'
+        elsif rates_hash[:tarifsEnClair]
+          rates_hash[:tarifsEnClair][:libelleFr]
+        end
+      end
+    end
+
+    def self.reservation(reservation_hash)
+      if reservation_hash
+        if reservation_hash[:complement]
+          reservation_hash[:complement][:libelleFr]
+        else
+          reservation_hash[:organismes]
+        end
+      end
+    end
+
+    def contact_text
+      entries = []
+      JSON.parse(contact).each_pair do |k, v|
+        entries << "#{k}: #{v}"
+      end
+      entries.join("\n")
+    end
+
+    def main_picture
+      pictures.any? ? pictures[0][:url] : "/#{Rails.application.config.apidae_pictures_path}/default/logo.png"
+    end
+
+    private
+
+    def self.node_value(node, key)
+      if node && node[key]
+        node[key][:libelleFr]
+      else
+        ''
+      end
+    end
+  end
+end

data/app/models/apidae/selection.rb

@@ -0,0 +1,89 @@
+module Apidae
+  class Selection < ActiveRecord::Base
+    has_and_belongs_to_many :objects, :class_name => 'Apidae::Object'
+
+    MAX_COUNT = 100
+    MAX_LOOPS = 10
+
+    def self.import(json_file)
+      selections_json = File.read(json_file)
+      selections_hashes = JSON.parse(selections_json, symbolize_names: true)
+      selections_hashes.each do |selection_data|
+        existing_sel = Apidae::Selection.find_by_apidae_id(selection_data[:id])
+        unless existing_sel
+          selection = Apidae::Selection.create!(
+              label: selection_data[:nom],
+              apidae_id: selection_data[:id]
+          )
+          if selection_data[:objetsTouristiques]
+            selection_data[:objetsTouristiques].each do |o|
+              apidae_object = Apidae::Object.find_by_apidae_id(o[:id])
+              selection.objects << apidae_object
+              selection.save!
+            end
+          end
+        end
+      end
+    end
+
+    def agenda(from, to)
+      agenda_entries = Rails.cache.read("#{apidae_id}_#{from}_#{to}")
+      if agenda_entries.nil?
+        query_result = {}
+        config = {
+            url: "#{Rails.application.config.apidae_api_url}/agenda/detaille/list-identifiants",
+            apiKey: Rails.application.config.apidae_api_key,
+            projetId: Rails.application.config.apidae_project_id,
+            first: 0,
+            count: MAX_COUNT,
+            selectionIds: [apidae_id],
+            dateDebut: from,
+            dateFin: to
+        }
+
+        loops = 0
+
+        response = JSON.parse get_response(config), symbolize_names: false
+        total = response['numFound']
+
+        query_result[:results] = response['objetTouristiqueIds'] || {}
+
+        while total > query_result[:results].values.flatten.length && loops < MAX_LOOPS
+          loops += 1
+          config[:first] += MAX_COUNT
+          response = JSON.parse get_response(config), symbolize_names: false
+          merge_results(response, query_result)
+        end
+        query_result[:count] = total
+        agenda_entries = query_result
+        Rails.cache.write("#{apidae_id}_#{from}_#{to}", query_result)
+      end
+      agenda_entries
+    end
+
+    private
+
+    def get_response(config)
+      response = ''
+      query = JSON.generate config.except(:url)
+      logger.info "Agenda query : #{config[:url]}?query=#{query}"
+      open("#{config[:url]}?query=#{CGI.escape query}") { |f|
+        f.each_line {|line| response += line if line}
+      }
+      response
+    end
+
+    def merge_results(response, query_results)
+      unless response['objetTouristiqueIds'].nil? || response['objetTouristiqueIds'].empty?
+        first_day = response['objetTouristiqueIds'].keys.first
+        if query_results[:results].has_key?(first_day)
+          query_results[:results][first_day] += response['objetTouristiqueIds'][first_day]
+        else
+          query_results[:results][first_day] = response['objetTouristiqueIds'][first_day]
+        end
+        query_results[:results].merge!(response['objetTouristiqueIds'].except(first_day))
+      end
+    end
+
+  end
+end

data/app/models/apidae/town.rb

@@ -0,0 +1,18 @@
+module Apidae
+  class Town < ActiveRecord::Base
+    def self.import(json_file)
+      result = true
+      towns_json = File.read(json_file)
+      towns_hashes = JSON.parse(towns_json, symbolize_names: true)
+      towns_hashes.each do |town_data|
+        Town.create!(name: town_data[:nom], postal_code: town_data[:codePostal], insee_code: town_data[:code],
+                     country: 'fr', apidae_id: town_data[:id])
+      end
+      result
+    end
+
+    def label
+      "#{name} (#{postal_code})"
+    end
+  end
+end

data/app/views/apidae/objects/_form.html.erb

@@ -0,0 +1,73 @@
+<%= form_for(@object) do |f| %>
+  <% if @object.errors.any? %>
+    <div id="error_explanation">
+      <h2><%= pluralize(@object.errors.count, "error") %> prohibited this object from being saved:</h2>
+
+      <ul>
+      <% @object.errors.full_messages.each do |message| %>
+        <li><%= message %></li>
+      <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <div class="field">
+    <%= f.label :address %><br>
+    <%= f.text_field :address %>
+  </div>
+  <div class="field">
+    <%= f.label :apidae_id %><br>
+    <%= f.number_field :apidae_id %>
+  </div>
+  <div class="field">
+    <%= f.label :apidae_type %><br>
+    <%= f.text_field :apidae_type %>
+  </div>
+  <div class="field">
+    <%= f.label :apidae_subtype %><br>
+    <%= f.text_field :apidae_subtype %>
+  </div>
+  <div class="field">
+    <%= f.label :title %><br>
+    <%= f.text_field :title %>
+  </div>
+  <div class="field">
+    <%= f.label :short_desc %><br>
+    <%= f.text_area :short_desc %>
+  </div>
+  <div class="field">
+    <%= f.label :contact %><br>
+    <%= f.text_area :contact %>
+  </div>
+  <div class="field">
+    <%= f.label :long_desc %><br>
+    <%= f.text_area :long_desc %>
+  </div>
+  <div class="field">
+    <%= f.label :type_data %><br>
+    <%= f.text_area :type_data %>
+  </div>
+  <div class="field">
+    <%= f.label :latitude %><br>
+    <%= f.text_field :latitude %>
+  </div>
+  <div class="field">
+    <%= f.label :longitude %><br>
+    <%= f.text_field :longitude %>
+  </div>
+  <div class="field">
+    <%= f.label :openings %><br>
+    <%= f.text_area :openings %>
+  </div>
+  <div class="field">
+    <%= f.label :rates %><br>
+    <%= f.text_area :rates %>
+  </div>
+  <div class="field">
+    <%= f.label :reservation %><br>
+    <%= f.text_area :reservation %>
+  </div>
+  <div class="actions">
+    <%= f.submit %>
+  </div>
+<% end %>