[DFC] match taxons to dfc product types

app/controllers/spree/admin/taxons_controller.rb

@@ -117,8 +117,8 @@ def destroy
 
       def taxon_params
         params.require(:taxon).permit(
-          :name, :parent_id, :position, :icon, :description, :permalink,
-          :taxonomy_id, :meta_description, :meta_keywords, :meta_title
+          :name, :parent_id, :position, :icon, :description, :permalink, :taxonomy_id,
+          :meta_description, :meta_keywords, :meta_title, :dfc_id
         )
       end
     end

app/views/spree/admin/taxons/_form.html.haml

@@ -1,31 +1,35 @@
 .row
   .alpha.five.columns
     = f.field_container :name do
-      = f.label :name, t(:name)
+      = f.label :name, t(".name")
       %span.required *
       %br/
       = error_message_on :taxon, :name, class: 'fullwidth title'
       = text_field :taxon, :name, class: 'fullwidth'
     = f.field_container :permalink_part do
-      = f.label :permalink_part, t(:permalink)
+      = f.label :permalink_part, t(".permalink")
       %span.required *
       %br/
       = @taxon.permalink.split("/")[0...-1].join("/") + "/"
       = text_field_tag :permalink_part, @permalink_part
     = f.field_container :meta_title do
-      = f.label :meta_title, t(:meta_title)
+      = f.label :meta_title, t(".meta_title")
       %br/
       = f.text_field :meta_title, class: 'fullwidth', rows: 6
     = f.field_container :meta_description do
-      = f.label :meta_description, t(:meta_description)
+      = f.label :meta_description, t(".meta_description")
       %br/
       = f.text_field :meta_description, class: 'fullwidth', rows: 6
     = f.field_container :meta_description do
-      = f.label :meta_keywords, t(:meta_keywords)
+      = f.label :meta_keywords, t(".meta_keywords")
       %br/
       = f.text_field :meta_keywords, class: 'fullwidth', rows: 6
+    = f.field_container :dfc_id do
+      = f.label :dfc_id, t(".dfc_id")
+      %br/
+      = f.text_field :dfc_id, class: 'fullwidth', rows: 6
   .omega.seven.columns
     = f.field_container :description do
-      = f.label :description, t(:description)
+      = f.label :description, t(".description")
       %br/
       = f.text_area :description, class: 'fullwidth', rows: 6

config/locales/en.yml

@@ -4479,6 +4479,15 @@ See the %{link} to find out more about %{sitename}'s features and to start using
           email: "Email"
           total: "Total"
           billing_address_name: "Name"
+      taxons:
+        form:
+          name: Name
+          permalink: Permalink
+          meta_title: Meta Title
+          meta_description: Meta Description
+          meta_keywords: Meta Keywords
+          description: Description
+          dfc_id: DFC URI 
       general_settings:
         edit:
           legal_settings: "Legal Settings"

db/migrate/20231027041224_add_dfc_name_to_spree_taxons.rb

@@ -0,0 +1,5 @@
+class AddDfcNameToSpreeTaxons < ActiveRecord::Migration[7.0]
+  def change
+    add_column :spree_taxons, :dfc_id, :string
+  end
+end

db/schema.rb

@@ -881,6 +881,7 @@
     t.string "meta_title", limit: 255
     t.string "meta_description", limit: 255
     t.string "meta_keywords", limit: 255
+    t.string "dfc_id"
     t.index ["parent_id"], name: "index_taxons_on_parent_id"
     t.index ["permalink"], name: "index_taxons_on_permalink"
     t.index ["taxonomy_id"], name: "index_taxons_on_taxonomy_id"

engines/dfc_provider/app/services/dfc_product_type_factory.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+class DfcProductTypeFactory
+  include Singleton
+
+  def self.for(dfc_id)
+    instance.for(dfc_id)
+  end
+
+  def initialize
+    @product_types = {}
+
+    populate_product_types
+  end
+
+  def for(dfc_id)
+    @product_types[dfc_id]
+  end
+
+  private
+
+  def populate_product_types
+    DfcLoader.connector.PRODUCT_TYPES.topConcepts.each do |product_type|
+      record_type(DfcLoader.connector.PRODUCT_TYPES, product_type.to_s)
+    end
+  end
+
+  def record_type(product_type_object, product_type)
+    current_product_type = product_type_object.public_send(product_type.to_s)
+
+    id = current_product_type.semanticId
+    @product_types[id] = current_product_type
+
+    # Narrower product types are defined as class method on the current product type object
+    narrowers = current_product_type.methods(false).sort
+
+    # Leaf node
+    return if narrowers.empty?
+
+    narrowers.each do |narrower|
+      # recursive call
+      record_type(current_product_type, narrower)
+    end
+  end
+end

engines/dfc_provider/app/services/supplied_product_builder.rb

@@ -11,19 +11,13 @@ def self.supplied_product(variant)
       id,
       name: variant.product_and_full_name,
       description: variant.description,
-      productType: product_type,
+      productType: product_type(variant),
       quantity: QuantitativeValueBuilder.quantity(variant),
       spree_product_id: variant.product.id,
       image_url: variant.product&.image&.url(:product)
     )
   end
 
-  # OFN product categories (taxons) are currently not standardised.
-  # This is just a dummy value for demos.
-  def self.product_type
-    DfcLoader.connector.PRODUCT_TYPES.VEGETABLE.NON_LOCAL_VEGETABLE
-  end
-
   def self.import_variant(supplied_product)
     product_id = supplied_product.spree_product_id
 
@@ -47,7 +41,7 @@ def self.import_product(supplied_product)
       name: supplied_product.name,
       description: supplied_product.description,
       price: 0, # will be in DFC Offer
-      primary_taxon: Spree::Taxon.first, # dummy value until we have a mapping
+      primary_taxon: taxon(supplied_product)
     ).tap do |product|
       QuantitativeValueBuilder.apply(supplied_product.quantity, product)
     end
@@ -56,10 +50,24 @@ def self.import_product(supplied_product)
   def self.apply(supplied_product, variant)
     variant.product.assign_attributes(
       description: supplied_product.description,
+      primary_taxon: taxon(supplied_product)
     )
 
     variant.display_name = supplied_product.name
     QuantitativeValueBuilder.apply(supplied_product.quantity, variant.product)
     variant.unit_value = variant.product.unit_value
   end
+
+  def self.product_type(variant)
+    taxon_dfc_id = variant.product.primary_taxon&.dfc_id
+
+    DfcProductTypeFactory.for(taxon_dfc_id)
+  end
+
+  def self.taxon(supplied_product)
+    dfc_id = supplied_product.productType.semanticId
+    Spree::Taxon.find_by(dfc_id: )
+  end
+
+  private_class_method :product_type, :taxon
 end

engines/dfc_provider/lib/data_food_consortium/connector/importer.rb

@@ -4,7 +4,7 @@
 
 module DataFoodConsortium
   module Connector
-    class Importer
+    class Importer # rubocop:disable Metrics/ClassLength
       TYPES = [
         DataFoodConsortium::Connector::CatalogItem,
         DataFoodConsortium::Connector::Enterprise,
@@ -106,7 +106,7 @@ def apply_statement(statement)
         if property.value.is_a?(Enumerable)
           property.value << value
         else
-          setter = guess_setter_name(statement.predicate)
+          setter = guess_setter_name(statement)
           subject.try(setter, value) if setter
         end
       end
@@ -128,10 +128,17 @@ def skos_concept(object)
           "https://github.com/datafoodconsortium/taxonomies/releases/latest/download/measures.rdf#",
           "dfc-m:"
         )
+
         SKOSParser.concepts[id]
       end
 
-      def guess_setter_name(predicate)
+      def guess_setter_name(statement)
+        predicate = statement.predicate
+
+        # Ideally the product models would be consitent with the rule below and use "type"
+        # instead of "productType" but alast they are not so we need this exception
+        return "productType=" if predicate.fragment == "hasType" && product_type?(statement)
+
         name =
           # Some predicates are named like `hasQuantity`
           # but the attribute name would be `quantity`.
@@ -141,6 +148,14 @@ def guess_setter_name(predicate)
 
         "#{name}="
       end
+
+      def product_type?(statement)
+        return true if statement.object.literal? && statement.object.value.match("dfc-pt")
+
+        return true if statement.object.path.match("productTypes")
+
+        false
+      end
     end
   end
 end

engines/dfc_provider/spec/fixtures/files/put_supplied_product.json

@@ -93,7 +93,7 @@
     "dfc-b:hasUnit": "dfc-m:Piece",
     "dfc-b:value": 17
   },
-  "dfc-b:hasType": "dfc-pt:non-local-vegetable",
+  "dfc-b:hasType": "dfc-pt:drink",
   "dfc-b:lifetime": "",
   "dfc-b:name": "Pesto novo",
   "dfc-b:totalTheoreticalStock": 0,

engines/dfc_provider/spec/lib/data_food_consortium/connector/importer_spec.rb

@@ -23,6 +23,7 @@
       name: "Tomato",
       description: "Awesome tomato",
       totalTheoreticalStock: 3,
+      productType: non_local_vegetable,
     )
   end
   let(:product_data) do
@@ -36,26 +37,8 @@
         "dfc-b:alcoholPercentage":0.0,
         "dfc-b:lifetime":"",
         "dfc-b:usageOrStorageCondition":"",
-        "dfc-b:totalTheoreticalStock":3
-      }
-    JSON
-  end
-  let(:product_data_with_context) do
-    <<~JSON
-      {
-        "@context": {
-          "dfc-b": "http://static.datafoodconsortium.org/ontologies/DFC_BusinessOntology.owl#",
-          "dfc-m": "http://static.datafoodconsortium.org/data/measures.rdf#",
-          "dfc-pt": "http://static.datafoodconsortium.org/data/productTypes.rdf#"
-        },
-        "@id":"https://example.net/tomato",
-        "@type":"dfc-b:SuppliedProduct",
-        "dfc-b:name":"Tomato",
-        "dfc-b:description":"Awesome tomato",
-        "dfc-b:alcoholPercentage":0.0,
-        "dfc-b:lifetime":"",
-        "dfc-b:usageOrStorageCondition":"",
-        "dfc-b:totalTheoreticalStock":3
+        "dfc-b:totalTheoreticalStock":3,
+        "dfc-b:hasType": "dfc-pt:non-local-vegetable"
       }
     JSON
   end
@@ -65,7 +48,8 @@
         "@context": {
           "dfc-b": "https://github.com/datafoodconsortium/ontology/releases/latest/download/DFC_BusinessOntology.owl#",
           "dfc-m": "https://github.com/datafoodconsortium/taxonomies/releases/latest/download/measures.rdf#",
-          "dfc-pt": "https://github.com/datafoodconsortium/taxonomies/releases/latest/download/productTypes.rdf#"
+          "dfc-pt": "https://github.com/datafoodconsortium/taxonomies/releases/latest/download/productTypes.rdf#",
+          "dfc-b:hasType":{"@type":"@id"}
         },
         "@id":"https://example.net/tomato",
         "@type":"dfc-b:SuppliedProduct",
@@ -74,7 +58,8 @@
         "dfc-b:alcoholPercentage":0.0,
         "dfc-b:lifetime":"",
         "dfc-b:usageOrStorageCondition":"",
-        "dfc-b:totalTheoreticalStock":3
+        "dfc-b:totalTheoreticalStock":3,
+        "dfc-b:hasType": "dfc-pt:non-local-vegetable"
       }
     JSON
   end
@@ -96,6 +81,11 @@
     end
     connector.MEASURES.PIECE
   end
+  let(:non_local_vegetable) do
+    connector.PRODUCT_TYPES.VEGETABLE.NON_LOCAL_VEGETABLE
+  end
+
+  before { connector.loadProductTypes(read_file("productTypes")) }
 
   it "imports a single object with simple properties" do
     result = import(product)
@@ -105,6 +95,7 @@
     expect(result.semanticId).to eq "https://example.net/tomato"
     expect(result.name).to eq "Tomato"
     expect(result.description).to eq "Awesome tomato"
+    expect(result.productType).to eq non_local_vegetable
     expect(result.totalTheoreticalStock).to eq 3
   end
 
@@ -116,17 +107,7 @@
     expect(result.semanticId).to eq "https://example.net/tomato"
     expect(result.name).to eq "Tomato"
     expect(result.description).to eq "Awesome tomato"
-    expect(result.totalTheoreticalStock).to eq 3
-  end
-
-  it "imports an object with included context" do
-    result = connector.import(product_data_with_context)
-
-    expect(result).to be_a DataFoodConsortium::Connector::SuppliedProduct
-    expect(result.semanticType).to eq "dfc-b:SuppliedProduct"
-    expect(result.semanticId).to eq "https://example.net/tomato"
-    expect(result.name).to eq "Tomato"
-    expect(result.description).to eq "Awesome tomato"
+    expect(result.productType).to eq non_local_vegetable
     expect(result.totalTheoreticalStock).to eq 3
   end
 
@@ -138,6 +119,7 @@
     expect(result.semanticId).to eq "https://example.net/tomato"
     expect(result.name).to eq "Tomato"
     expect(result.description).to eq "Awesome tomato"
+    expect(result.productType).to eq non_local_vegetable
     expect(result.totalTheoreticalStock).to eq 3
   end
 
@@ -154,6 +136,7 @@
     expect(item.semanticId).to eq "https://example.net/tomatoItem"
     expect(tomato.name).to eq "Tomato"
     expect(tomato.description).to eq "Awesome tomato"
+    expect(tomato.productType).to eq non_local_vegetable
     expect(tomato.totalTheoreticalStock).to eq 3
   end
 
@@ -164,6 +147,7 @@
 
     expect(tomato.name).to eq "Tomato"
     expect(tomato.quantity).to eq items
+    expect(tomato.productType).to eq non_local_vegetable
     expect(items.value).to eq 5
     expect(items.unit).to eq piece
   end

engines/dfc_provider/spec/requests/catalog_items_spec.rb

@@ -17,6 +17,14 @@
       :base_product,
       id: 90_000, supplier: enterprise, name: "Apple", description: "Red",
       variants: [variant],
+      primary_taxon: non_local_vegetable
+    )
+  }
+  let(:non_local_vegetable) {
+    build(
+      :taxon,
+      name: "Non Local Vegetable",
+      dfc_id: "https://github.com/datafoodconsortium/taxonomies/releases/latest/download/productTypes.rdf#non-local-vegetable"
     )
   }
   let(:variant) { build(:base_variant, id: 10_001, unit_value: 1, sku: "AR") }

engines/dfc_provider/spec/requests/enterprises_spec.rb

@@ -29,6 +29,14 @@
       :product_with_image,
       id: 90_000, supplier: enterprise, name: "Apple", description: "Round",
       variants: [variant],
+      primary_taxon: non_local_vegetable
+    )
+  }
+  let(:non_local_vegetable) {
+    build(
+      :taxon,
+      name: "Non Local Vegetable",
+      dfc_id: "https://github.com/datafoodconsortium/taxonomies/releases/latest/download/productTypes.rdf#non-local-vegetable"
     )
   }
   let(:variant) { build(:base_variant, id: 10_001, unit_value: 1, sku: "APP") }