apidae-engine-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 522e00b9e5e5656a07b2f601908f06cd90c98fab
+  data.tar.gz: 31907b78ba93e58357ea76f49007be7c3f61e17b
+SHA512:
+  metadata.gz: 0fc74354fca282cf6f9e9d1bd5c490079a8ff7e8b31bb7b197a728ce0853f0b17f16c577f4c0bcd166107d01b4dd1107b7c1e4e00b300751e89e0638f6182d0c
+  data.tar.gz: a322836f8fd43d501d06222dbe0af6cca651feecb77230be4c66a160c2a1133ec130915c2956f18462d484fc9df2ddfae340d9e255837f550789e48a087b9f8b

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
+
+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