dfc-linkml-connector 2.0.6

data/lib/core/json_ld_serializer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'json/ld'
+
+module DfcLinkmlConnector
+  module Core
+    # Serializes DFC semantic objects to JSON-LD.
+    class JsonLdSerializer
+      def initialize(context = nil, context_url = nil)
+        @context = context
+        @context_url = context_url
+      end
+
+      # Returns the JSON-LD document as a Hash with CURIE predicates
+      # (uncompacted). Single objects are returned as-is; multiple objects
+      # are wrapped in an @graph.
+      def serialize(*objects)
+        if objects.length == 1
+          return _serialize_object(objects.first)
+        end
+
+        {
+          "@context" => _context_iri,
+          "@graph" => objects.map { |obj| _serialize_object(obj) },
+        }
+      end
+
+      # Returns a compacted JSON-LD JSON string using the original context.
+      # Falls back to the plain serialization when no context is available,
+      # keeping the context URL so CURIE predicates stay expandable.
+      def to_json(*objects)
+        doc = serialize(*objects)
+        inner = _inner_context
+        if inner.nil?
+          doc["@context"] ||= _context_iri
+        else
+          expanded = JSON::LD::API.expand(doc.merge("@context" => inner))
+          doc = JSON::LD::API.compact(expanded, inner)
+          doc["@context"] = _context_iri
+        end
+        JSON.pretty_generate(doc)
+      end
+
+      private
+
+      def _context_iri
+        @context_url || Connector.default_context_url
+      end
+
+      def _inner_context
+        return nil if @context.nil?
+        @context.is_a?(Hash) && @context.key?("@context") ? @context["@context"] : @context
+      end
+
+      def _serialize_object(obj)
+        result = {
+          "@id" => obj.semanticId,
+          "@type" => obj.semanticType,
+        }
+
+        obj.instance_variable_get(:@semanticProperties).each do |predicate, prop|
+          value = prop.getter.call
+          next if value.nil?
+
+          if value.is_a?(Array)
+            next if value.empty?
+            if value.first.is_a?(SemanticObject)
+              result[predicate] = value.map { |v| v.semanticId }
+            else
+              result[predicate] = value
+            end
+          elsif value.is_a?(SemanticObject)
+            result[predicate] = value.semanticId
+          elsif value.is_a?(Hash)
+            # Embedded blank node (e.g. original Price value object without
+            # @id): keep as-is so it serializes to JSON-LD, not Ruby inspect.
+            result[predicate] = value
+          elsif value.is_a?(Numeric) || value == true || value == false
+            result[predicate] = value
+          elsif value.is_a?(String)
+            result[predicate] = value
+          else
+            result[predicate] = value.to_s
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/core/semantic_object.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module DfcLinkmlConnector
+  module Core
+    # Base class for all DFC semantic objects.
+    # Maintains a type registry for JSON-LD import.
+    class SemanticObject
+      @type_registry = {}
+
+      class << self
+        attr_reader :type_registry
+      end
+
+      attr_accessor :semanticId
+      attr_accessor :semanticType
+
+      def initialize(semanticId)
+        @semanticId = semanticId
+        @semanticType = nil
+        @semanticProperties = {}
+      end
+
+      def registerSemanticProperty(predicate, &getter)
+        prop = SemanticProperty.new(predicate, &getter)
+        @semanticProperties[predicate] = prop
+        prop
+      end
+
+      def registered_predicates
+        @semanticProperties.keys
+      end
+
+      def registered_value(predicate)
+        prop = @semanticProperties[predicate]
+        prop&.getter&.call
+      end
+
+      def semantic_property_value(predicate)
+        prop = @semanticProperties[predicate]
+        prop&.getter&.call
+      end
+
+      def to_jsonld(context = nil)
+        result = {
+          "@context" => context || default_context,
+          "@id" => @semanticId,
+          "@type" => @semanticType,
+        }
+
+        @semanticProperties.each do |predicate, prop|
+          value = prop.getter.call
+          next if value.nil?
+
+          if value.is_a?(Array)
+            next if value.empty?
+            if value.first.is_a?(SemanticObject)
+              result[predicate] = value.map { |v| v.semanticId }
+            else
+              result[predicate] = value
+            end
+          elsif value.is_a?(SemanticObject)
+            result[predicate] = value.semanticId
+          elsif value.is_a?(Numeric) || value == true || value == false
+            result[predicate] = value
+          elsif value.is_a?(Hash)
+            # Embedded blank node (e.g. original Price value object without
+            # @id): keep as-is so it serializes to JSON-LD, not Ruby inspect.
+            result[predicate] = value
+          else
+            result[predicate] = value.to_s
+          end
+        end
+
+        result
+      end
+
+      def to_json(context = nil)
+        JSON.generate(to_jsonld(context))
+      end
+
+      private
+
+      def default_context
+        Connector.default_context_url
+      end
+
+      class SemanticProperty
+        attr_accessor :predicate
+        attr_accessor :getter
+        attr_accessor :valueSetter
+
+        def initialize(predicate, &getter)
+          @predicate = predicate
+          @getter = getter
+        end
+      end
+    end
+  end
+end

data/lib/core/vocabulary_loader.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module DfcLinkmlConnector
+  module Core
+    # Loads DFC SKOS vocabularies from JSON-LD files.
+    # Supports fetching from versioned w3id URLs or loading local data.
+    class VocabularyLoader
+      TAXONOMY_BASE_URL = "https://w3id.org/dfc/taxonomies".freeze
+      BUNDLED_DIR = File.expand_path("../../vocabularies", __dir__).freeze
+      BUNDLED_FILES = {
+        "Facet" => "facet.jsonld",
+        "Measure" => "measure.jsonld",
+        "ProductType" => "product_type.jsonld",
+        "Scope" => "scope.jsonld",
+        "VocabularyTerm" => "vocabulary_term.jsonld",
+      }.freeze
+      # Maps the taxonomy URL file name to the internal vocabulary key.
+      # Keys are plural/lowercased URL segments (e.g. "facets") to match TS
+      # VocabularyLoader.URL_TO_KEY and the w3id taxonomy URLs.
+      URL_TO_KEY = {
+        "facets" => "Facet",
+        "measures" => "Measure",
+        "producttypes" => "ProductType",
+        "scopes" => "Scope",
+        "vocabularyterms" => "VocabularyTerm",
+      }.freeze
+
+      def initialize(taxonomy_version: "2.0.0", ontology_version: "2.0.0")
+        @taxonomy_version = taxonomy_version
+        @ontology_version = ontology_version
+        @vocabularies = {}
+      end
+
+      def load_bundled(name)
+        file = BUNDLED_FILES[name]
+        return self unless file
+        path = File.join(BUNDLED_DIR, file)
+        return self unless File.exist?(path)
+        load(name, JSON.parse(File.read(path)))
+      end
+
+      def load(name, json_data)
+        concepts = {}
+        json_data.fetch("@graph", []).each do |entry|
+          types = entry["@type"]
+          types = [types] unless types.is_a?(Array)
+          is_concept = types&.any? { |t| t == "skos:Concept" || t == "http://www.w3.org/2004/02/skos/core#Concept" }
+          next unless is_concept
+          notation = extract_concept_key(entry)
+          next unless notation
+          concepts[notation] = entry
+        end
+        @vocabularies[name] = concepts
+        self
+      end
+
+      private
+
+      def extract_concept_key(entry)
+        candidates = ["skos:notation", "http://www.w3.org/2004/02/skos/core#notation", "skos:prefLabel", "http://www.w3.org/2004/02/skos/core#prefLabel"]
+        candidates.each do |field|
+          value = entry[field]
+          next if value.nil?
+          return value if value.is_a?(String)
+          if value.is_a?(Array)
+            value.each do |item|
+              return item if item.is_a?(String)
+              if item.is_a?(Hash) && item["@value"].is_a?(String)
+                return item["@value"]
+              end
+            end
+          end
+        end
+        nil
+      end
+
+      public
+
+      def load_from_url(name)
+        url = "#{TAXONOMY_BASE_URL}/v#{@taxonomy_version}/#{name}.json"
+        uri = URI(url)
+        request = Net::HTTP::Get.new(uri)
+        request["dfc-version"] = @ontology_version
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
+        raise "Failed to fetch taxonomy from #{url}: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+        json_data = JSON.parse(response.body)
+        key = URL_TO_KEY.fetch(name.downcase, name)
+        load(key, json_data)
+      end
+
+      def vocabulary(name)
+        @vocabularies[name] || {}
+      end
+
+      def facet(key = nil)
+        vocab = vocabulary("Facet")
+        key ? vocab[key] : vocab
+      end
+
+      def measure(key = nil)
+        vocab = vocabulary("Measure")
+        key ? vocab[key] : vocab
+      end
+
+      def product_type(key = nil)
+        vocab = vocabulary("ProductType")
+        key ? vocab[key] : vocab
+      end
+
+      def scope(key = nil)
+        vocab = vocabulary("Scope")
+        key ? vocab[key] : vocab
+      end
+
+      def vocabulary_term(key = nil)
+        vocab = vocabulary("VocabularyTerm")
+        key ? vocab[key] : vocab
+      end
+    end
+  end
+end

data/lib/dfc_linkml_connector.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative 'core/semantic_object'
+require_relative 'core/vocabulary_loader'
+require_relative 'core/json_ld_serializer'
+require_relative 'core/connector'
+
+require_relative 'models/address'
+require_relative 'models/agent'
+require_relative 'models/allergen_characteristic'
+require_relative 'models/as_planned_consumption_flow'
+require_relative 'models/as_planned_local_consumption_flow'
+require_relative 'models/as_planned_local_production_flow'
+require_relative 'models/as_planned_local_transformation'
+require_relative 'models/as_planned_production_flow'
+require_relative 'models/as_planned_transformation'
+require_relative 'models/as_realized_consumption_flow'
+require_relative 'models/as_realized_production_flow'
+require_relative 'models/as_realized_transformation'
+require_relative 'models/brand'
+require_relative 'models/catalog'
+require_relative 'models/catalog_item'
+require_relative 'models/certfication'
+require_relative 'models/collection'
+require_relative 'models/concept'
+require_relative 'models/concept_scheme'
+require_relative 'models/consumption_flow'
+require_relative 'models/coordination'
+require_relative 'models/customer_category'
+require_relative 'models/ditributed_representation'
+require_relative 'models/defined_product'
+require_relative 'models/delivery_option'
+require_relative 'models/delivery_step'
+require_relative 'models/enterprise'
+require_relative 'models/feature'
+require_relative 'models/functional_product'
+require_relative 'models/geometry'
+require_relative 'models/how_subject'
+require_relative 'models/individual'
+require_relative 'models/ingredient'
+require_relative 'models/labelling_characteristic'
+require_relative 'models/length'
+require_relative 'models/localized_product'
+require_relative 'models/nutrient_characteristic'
+require_relative 'models/offer'
+require_relative 'models/opening_hours_specification'
+require_relative 'models/order'
+require_relative 'models/order_line'
+require_relative 'models/organization'
+require_relative 'models/payment_method'
+require_relative 'models/person'
+require_relative 'models/phone_number'
+require_relative 'models/physical_characteristic'
+require_relative 'models/physical_place'
+require_relative 'models/physical_product'
+require_relative 'models/pick_up_step'
+require_relative 'models/pickup_option'
+require_relative 'models/place'
+require_relative 'models/platform'
+require_relative 'models/point'
+require_relative 'models/polygon'
+require_relative 'models/price'
+require_relative 'models/product_batch'
+require_relative 'models/product_option'
+require_relative 'models/product_option_value'
+require_relative 'models/production_flow'
+require_relative 'models/properties'
+require_relative 'models/quantitative_value'
+require_relative 'models/real_stock'
+require_relative 'models/representation_pivot'
+require_relative 'models/represented_thing'
+require_relative 'models/route'
+require_relative 'models/sale_session'
+require_relative 'models/shipment'
+require_relative 'models/shipping_option'
+require_relative 'models/social_media'
+require_relative 'models/step'
+require_relative 'models/stock'
+require_relative 'models/supplied_product'
+require_relative 'models/technical_product'
+require_relative 'models/temperature'
+require_relative 'models/template_sale_session'
+require_relative 'models/theoritical_stock'
+require_relative 'models/transaction'
+require_relative 'models/transformation'
+require_relative 'models/value_r_e_c_u_r'
+require_relative 'models/variant'
+require_relative 'models/variant_caracteristic'
+require_relative 'models/vehicle'
+require_relative 'models/vevent'
+require_relative 'models/virtual_place'
+require_relative 'models/volume'
+require_relative 'models/weight'
+require_relative 'models/what_subject'
+require_relative 'models/where_subject'
+require_relative 'models/who_subject'
+
+module DfcLinkmlConnector
+  VERSION = '2.0.0'
+  ONTOLOGY_VERSION = '2.0.0'
+  TAXONOMY_VERSION = '2.0.0'
+end

data/lib/models/address.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Address
+require_relative '../core/semantic_object'
+require_relative 'where_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Address < WhereSubject
+      SEMANTIC_TYPE = "dfc-b:Address".freeze
+
+      # @return [String]
+      attr_accessor :city
+
+      # @return [String]
+      attr_accessor :country
+
+      # @return [Float]
+      attr_accessor :latitude
+
+      # @return [Float]
+      attr_accessor :longitude
+
+      # @return [String]
+      attr_accessor :postcode
+
+      # @return [String]
+      attr_accessor :region
+
+      # @return [String]
+      attr_accessor :street
+
+      # @return [String]
+      attr_accessor :address_of
+
+      # @return [String]
+      attr_accessor :has_country
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, city: nil, country: nil, latitude: nil, longitude: nil, postcode: nil, region: nil, street: nil, addressOf: nil, hasCountry: nil
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, city: nil, country: nil, latitude: nil, longitude: nil, postcode: nil, region: nil, street: nil, addressOf: nil, hasCountry: nil)
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @city = city
+        @country = country
+        @latitude = latitude
+        @longitude = longitude
+        @postcode = postcode
+        @region = region
+        @street = street
+        @address_of = addressOf
+        @has_country = hasCountry
+        self.semanticType = "dfc-b:Address"
+        registerSemanticProperty("dfc-b:city", &method("city")).valueSetter = method("city=")
+        registerSemanticProperty("dfc-b:country", &method("country")).valueSetter = method("country=")
+        registerSemanticProperty("dfc-b:latitude", &method("latitude")).valueSetter = method("latitude=")
+        registerSemanticProperty("dfc-b:longitude", &method("longitude")).valueSetter = method("longitude=")
+        registerSemanticProperty("dfc-b:postcode", &method("postcode")).valueSetter = method("postcode=")
+        registerSemanticProperty("dfc-b:region", &method("region")).valueSetter = method("region=")
+        registerSemanticProperty("dfc-b:street", &method("street")).valueSetter = method("street=")
+        registerSemanticProperty("dfc-b:addressOf", &method("address_of")).valueSetter = method("address_of=")
+        registerSemanticProperty("dfc-b:hasCountry", &method("has_country")).valueSetter = method("has_country=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/agent.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #Agent
+require_relative '../core/semantic_object'
+require_relative 'who_subject'
+
+
+module DfcLinkmlConnector
+  module Models
+    class Agent < WhoSubject
+      SEMANTIC_TYPE = "dfc-b:Agent".freeze
+
+      # @return [String]
+      attr_accessor :email
+
+      # @return [String]
+      attr_accessor :logo
+
+      # @return [String]
+      attr_accessor :website_page
+
+      # @return [String]
+      attr_accessor :has_phone_number
+
+      # @return [String]
+      attr_accessor :social_media
+
+      # @return [String]
+      attr_accessor :owns
+
+      # @return [String]
+      attr_accessor :sells
+
+      # @return [Person, String]
+      attr_accessor :affiliated_to
+
+      # @return [Array<Address, String>]
+      attr_accessor :address
+
+      # @return [Array<CustomerCategory, String>]
+      attr_accessor :is_member_of
+
+      # @return [Array<Order, String>]
+      attr_accessor :orders
+
+      # @return [Array<FunctionalProduct, String>]
+      attr_accessor :requests
+
+      # @param semanticId [String]
+      # @param date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, email: nil, logo: nil, websitePage: nil, hasPhoneNumber: nil, socialMedia: nil, owns: nil, sells: nil, affiliatedTo: nil, address: [], isMemberOf: [], orders: [], requests: []
+      def initialize(semanticId, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, email: nil, logo: nil, websitePage: nil, hasPhoneNumber: nil, socialMedia: nil, owns: nil, sells: nil, affiliatedTo: nil, address: [], isMemberOf: [], orders: [], requests: [])
+        super(semanticId, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension)
+        @email = email
+        @logo = logo
+        @website_page = websitePage
+        @has_phone_number = hasPhoneNumber
+        @social_media = socialMedia
+        @owns = owns
+        @sells = sells
+        @affiliated_to = affiliatedTo
+        @address = address
+        @is_member_of = isMemberOf
+        @orders = orders
+        @requests = requests
+        self.semanticType = "dfc-b:Agent"
+        registerSemanticProperty("dfc-b:email", &method("email")).valueSetter = method("email=")
+        registerSemanticProperty("dfc-b:logo", &method("logo")).valueSetter = method("logo=")
+        registerSemanticProperty("dfc-b:websitePage", &method("website_page")).valueSetter = method("website_page=")
+        registerSemanticProperty("dfc-b:hasPhoneNumber", &method("has_phone_number")).valueSetter = method("has_phone_number=")
+        registerSemanticProperty("dfc-b:hasSocialMedia", &method("social_media")).valueSetter = method("social_media=")
+        registerSemanticProperty("dfc-b:owns", &method("owns")).valueSetter = method("owns=")
+        registerSemanticProperty("dfc-b:sells", &method("sells")).valueSetter = method("sells=")
+        registerSemanticProperty("dfc-b:affiliatedTo", &method("affiliated_to")).valueSetter = method("affiliated_to=")
+        registerSemanticProperty("dfc-b:hasAddress", &method("address")).valueSetter = method("address=")
+        registerSemanticProperty("dfc-b:isMemberOf", &method("is_member_of")).valueSetter = method("is_member_of=")
+        registerSemanticProperty("dfc-b:orders", &method("orders")).valueSetter = method("orders=")
+        registerSemanticProperty("dfc-b:requests", &method("requests")).valueSetter = method("requests=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/allergen_characteristic.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #AllergenCharacteristic
+require_relative '../core/semantic_object'
+
+
+module DfcLinkmlConnector
+  module Models
+    class AllergenCharacteristic < Core::SemanticObject
+      SEMANTIC_TYPE = "dfc-b:AllergenCharacteristic".freeze
+
+      # @return [String]
+      attr_accessor :allergen_characteristic_of
+
+      # @return [String]
+      attr_accessor :date
+
+      # @return [String]
+      attr_accessor :description
+
+      # @return [String]
+      attr_accessor :name
+
+      # @return [String]
+      attr_accessor :characteristic_of
+
+      # @return [String]
+      attr_accessor :dimension
+
+      # @return [Concept, String]
+      attr_accessor :allergen_dimension
+
+      # @param semanticId [String]
+      # @param allergenCharacteristicOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, allergenDimension: nil
+      def initialize(semanticId, allergenCharacteristicOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, allergenDimension: nil)
+        super(semanticId)
+        @allergen_characteristic_of = allergenCharacteristicOf
+        @date = date
+        @description = description
+        @name = name
+        @characteristic_of = characteristicOf
+        @dimension = dimension
+        @allergen_dimension = allergenDimension
+        self.semanticType = "dfc-b:AllergenCharacteristic"
+        registerSemanticProperty("dfc-b:allergenCharacteristicOf", &method("allergen_characteristic_of")).valueSetter = method("allergen_characteristic_of=")
+        registerSemanticProperty("dfc-b:date", &method("date")).valueSetter = method("date=")
+        registerSemanticProperty("dfc-b:description", &method("description")).valueSetter = method("description=")
+        registerSemanticProperty("dfc-b:name", &method("name")).valueSetter = method("name=")
+        registerSemanticProperty("dfc-b:characteristicOf", &method("characteristic_of")).valueSetter = method("characteristic_of=")
+        registerSemanticProperty("dfc-b:hasDimension", &method("dimension")).valueSetter = method("dimension=")
+        registerSemanticProperty("dfc-b:hasAllergenDimension", &method("allergen_dimension")).valueSetter = method("allergen_dimension=")
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/as_planned_consumption_flow.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #AsPlannedConsumptionFlow
+require_relative '../core/semantic_object'
+require_relative 'consumption_flow'
+
+
+module DfcLinkmlConnector
+  module Models
+    class AsPlannedConsumptionFlow < ConsumptionFlow
+      SEMANTIC_TYPE = "dfc-b:AsPlannedConsumptionFlow".freeze
+
+      # @param semanticId [String]
+      # @param quantity: nil, consumes: nil, inputOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil
+      def initialize(semanticId, quantity: nil, consumes: nil, inputOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil)
+        super(semanticId, quantity: quantity, consumes: consumes, inputOf: inputOf, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, hasQuantity: hasQuantity)
+
+        self.semanticType = "dfc-b:AsPlannedConsumptionFlow"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end

data/lib/models/as_planned_local_consumption_flow.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Class from DFC Business Ontology: #AsPlannedLocalConsumptionFlow
+require_relative '../core/semantic_object'
+require_relative 'consumption_flow'
+
+
+module DfcLinkmlConnector
+  module Models
+    class AsPlannedLocalConsumptionFlow < ConsumptionFlow
+      SEMANTIC_TYPE = "dfc-b:AsPlannedLocalConsumptionFlow".freeze
+
+      # @param semanticId [String]
+      # @param quantity: nil, consumes: nil, inputOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil
+      def initialize(semanticId, quantity: nil, consumes: nil, inputOf: nil, date: nil, description: nil, name: nil, characteristicOf: nil, dimension: nil, hasQuantity: nil)
+        super(semanticId, quantity: quantity, consumes: consumes, inputOf: inputOf, date: date, description: description, name: name, characteristicOf: characteristicOf, dimension: dimension, hasQuantity: hasQuantity)
+
+        self.semanticType = "dfc-b:AsPlannedLocalConsumptionFlow"
+
+      end
+
+      Core::SemanticObject.type_registry[SEMANTIC_TYPE] = self
+    end
+  end
+end