From c94bd9231101dc41c691fdb738deb357cdf8f14f Mon Sep 17 00:00:00 2001 From: Maikel Linke Date: Fri, 22 Mar 2024 13:49:51 +1100 Subject: [PATCH 1/5] Simplify DFC request retry logic Big thanks to David Cook for a much better pattern. --- .../dfc_provider/app/services/dfc_request.rb | 26 +++++++++++-------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/engines/dfc_provider/app/services/dfc_request.rb b/engines/dfc_provider/app/services/dfc_request.rb index 8de0108d99..76ff6e2064 100644 --- a/engines/dfc_provider/app/services/dfc_request.rb +++ b/engines/dfc_provider/app/services/dfc_request.rb @@ -16,30 +16,34 @@ class DfcRequest def get(url) response = request(url) - return response.body if response.status == 200 + if response.status != 200 && token_stale? + refresh_access_token! + response = request(url) + end - return "" if @user.oidc_account.updated_at > 15.minutes.ago - - refresh_access_token! - - response = request(url) response.body end private def request(url) - connection = Faraday.new( + only_public_connections do + connection.get(url) + end + end + + def token_stale? + @user.oidc_account.updated_at < 15.minutes.ago + end + + def connection + Faraday.new( request: { timeout: 30 }, headers: { 'Content-Type' => 'application/json', 'Authorization' => "Bearer #{@user.oidc_account.token}", } ) - - only_public_connections do - connection.get(url) - end end def only_public_connections(&) From 635234a889fe498407c7fdf3f8ecb3dea5ec561c Mon Sep 17 00:00:00 2001 From: Maikel Linke Date: Fri, 22 Mar 2024 14:21:14 +1100 Subject: [PATCH 2/5] Enable POSTing DFC data --- .../admin/dfc_product_imports_controller.rb | 2 +- engines/dfc_provider/app/services/dfc_request.rb | 16 ++++++++++------ .../spec/services/dfc_request_spec.rb | 15 ++++++++++++--- 3 files changed, 23 insertions(+), 10 deletions(-) diff --git a/app/controllers/admin/dfc_product_imports_controller.rb b/app/controllers/admin/dfc_product_imports_controller.rb index 1b3f8dfb88..8dc580afbd 100644 --- a/app/controllers/admin/dfc_product_imports_controller.rb +++ b/app/controllers/admin/dfc_product_imports_controller.rb @@ -20,7 +20,7 @@ module Admin catalog_url = params.require(:catalog_url) - json_catalog = DfcRequest.new(spree_current_user).get(catalog_url) + json_catalog = DfcRequest.new(spree_current_user).call(catalog_url) graph = DfcIo.import(json_catalog) # * First step: import all products for given enterprise. diff --git a/engines/dfc_provider/app/services/dfc_request.rb b/engines/dfc_provider/app/services/dfc_request.rb index 76ff6e2064..949ec23bad 100644 --- a/engines/dfc_provider/app/services/dfc_request.rb +++ b/engines/dfc_provider/app/services/dfc_request.rb @@ -13,12 +13,12 @@ class DfcRequest @user = user end - def get(url) - response = request(url) + def call(url, data = nil) + response = request(url, data) - if response.status != 200 && token_stale? + if response.status >= 400 && token_stale? refresh_access_token! - response = request(url) + response = request(url, data) end response.body @@ -26,9 +26,13 @@ class DfcRequest private - def request(url) + def request(url, data = nil) only_public_connections do - connection.get(url) + if data + connection.post(url, data) + else + connection.get(url) + end end end diff --git a/engines/dfc_provider/spec/services/dfc_request_spec.rb b/engines/dfc_provider/spec/services/dfc_request_spec.rb index d1e82d17ef..ea17ae02af 100644 --- a/engines/dfc_provider/spec/services/dfc_request_spec.rb +++ b/engines/dfc_provider/spec/services/dfc_request_spec.rb @@ -12,7 +12,16 @@ RSpec.describe DfcRequest do stub_request(:get, "http://example.net/api"). to_return(status: 200, body: '{"@context":"/"}') - expect(api.get("http://example.net/api")).to eq '{"@context":"/"}' + expect(api.call("http://example.net/api")).to eq '{"@context":"/"}' + end + + it "posts a DFC document" do + json = '{"name":"new season apples"}' + stub_request(:post, "http://example.net/api"). + with(body: json). + to_return(status: 201) # Created + + expect(api.call("http://example.net/api", json)).to eq "" end it "refreshes the access token on fail", vcr: true do @@ -30,7 +39,7 @@ RSpec.describe DfcRequest do account.updated_at = 1.day.ago expect { - api.get("http://example.net/api") + api.call("http://example.net/api") }.to change { account.token }.and change { @@ -44,7 +53,7 @@ RSpec.describe DfcRequest do user.oidc_account.updated_at = 1.minute.ago - expect(api.get("http://example.net/api")).to eq "" + expect(api.call("http://example.net/api")).to eq "" # Trying to reach the OIDC server via network request to refresh the token # would raise errors because we didn't setup Webmock or VCR. From 1f006627094ef321e7b1e9ae0c9e435d63f28d3e Mon Sep 17 00:00:00 2001 From: Maikel Linke Date: Thu, 23 May 2024 17:02:49 +1000 Subject: [PATCH 3/5] Add service to access FDC API The current implementation of the FDC is not adhering to the DFC standard. The difference is added in this compatibility layer. This should be temporary code. The FDC dev team should change their API in their next development cycle. --- .../dfc_provider/app/services/fdc_request.rb | 33 +++ .../spec/services/fdc_request_spec.rb | 36 +++ ...e_access_token_and_retrieves_a_catalog.yml | 206 ++++++++++++++++++ spec/support/vcr_setup.rb | 5 + 4 files changed, 280 insertions(+) create mode 100644 engines/dfc_provider/app/services/fdc_request.rb create mode 100644 engines/dfc_provider/spec/services/fdc_request_spec.rb create mode 100644 spec/fixtures/vcr_cassettes/FdcRequest/refreshes_the_access_token_and_retrieves_a_catalog.yml diff --git a/engines/dfc_provider/app/services/fdc_request.rb b/engines/dfc_provider/app/services/fdc_request.rb new file mode 100644 index 0000000000..5252cff85a --- /dev/null +++ b/engines/dfc_provider/app/services/fdc_request.rb @@ -0,0 +1,33 @@ +# frozen_string_literal: true + +require "private_address_check" +require "private_address_check/tcpsocket_ext" + +# Request a JSON document from the FDC API with authentication. +# +# Currently, the API doesn't quite comply with the DFC standard and we need +# to authenticate a little bit differently. +# +# And then we get slightly different data as well. +class FdcRequest < DfcRequest + # Override main method to POST authorization data. + def call(url, data = {}) + response = request(url, auth_data.merge(data).to_json) + + if response.status >= 400 && token_stale? + refresh_access_token! + response = request(url, auth_data.merge(data).to_json) + end + + response.body + end + + private + + def auth_data + { + userId: @user.oidc_account.uid, + accessToken: @user.oidc_account.token, + } + end +end diff --git a/engines/dfc_provider/spec/services/fdc_request_spec.rb b/engines/dfc_provider/spec/services/fdc_request_spec.rb new file mode 100644 index 0000000000..c1f59d40f8 --- /dev/null +++ b/engines/dfc_provider/spec/services/fdc_request_spec.rb @@ -0,0 +1,36 @@ +# frozen_string_literal: true + +require_relative "../spec_helper" + +RSpec.describe FdcRequest do + subject(:api) { FdcRequest.new(user) } + + let(:user) { build(:oidc_user) } + let(:account) { user.oidc_account } + let(:url) { + "https://food-data-collaboration-produc-fe870152f634.herokuapp.com/fdc/products?shop=test-hodmedod.myshopify.com" + } + + it "refreshes the access token and retrieves a catalog", vcr: true do + # A refresh is only attempted if the token is stale. + account.uid = "testdfc@protonmail.com" + account.refresh_token = ENV.fetch("OPENID_REFRESH_TOKEN") + account.updated_at = 1.day.ago + + response = nil + expect { + response = api.call(url) + }.to change { + account.token + }.and change { + account.refresh_token + } + + json = JSON.parse(response) + expect(json["message"]).to eq "Products retrieved successfully" + + graph = DfcIo.import(json["products"]) + products = graph.select { |s| s.semanticType == "dfc-b:SuppliedProduct" } + expect(products).to be_present + end +end diff --git a/spec/fixtures/vcr_cassettes/FdcRequest/refreshes_the_access_token_and_retrieves_a_catalog.yml b/spec/fixtures/vcr_cassettes/FdcRequest/refreshes_the_access_token_and_retrieves_a_catalog.yml new file mode 100644 index 0000000000..636e061690 --- /dev/null +++ b/spec/fixtures/vcr_cassettes/FdcRequest/refreshes_the_access_token_and_retrieves_a_catalog.yml @@ -0,0 +1,206 @@ +--- +http_interactions: +- request: + method: post + uri: https://food-data-collaboration-produc-fe870152f634.herokuapp.com/fdc/products?shop=test-hodmedod.myshopify.com + body: + encoding: UTF-8 + string: '{"userId":"testdfc@protonmail.com","accessToken":null}' + headers: + Content-Type: + - application/json + Authorization: + - "" + User-Agent: + - Faraday v2.9.0 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 403 + message: Forbidden + headers: + Server: + - Cowboy + Report-To: + - '{"group":"heroku-nel","max_age":3600,"endpoints":[{"url":"https://nel.heroku.com/reports?ts=1716515324&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=QHSHL9RlLovwwwatlK4mrZMZ6powGfrf8MG7QDavBV4%3D"}]}' + Reporting-Endpoints: + - heroku-nel=https://nel.heroku.com/reports?ts=1716515324&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=QHSHL9RlLovwwwatlK4mrZMZ6powGfrf8MG7QDavBV4%3D + Nel: + - '{"report_to":"heroku-nel","max_age":3600,"success_fraction":0.005,"failure_fraction":0.05,"response_headers":["Via"]}' + Connection: + - keep-alive + X-Powered-By: + - Express + Access-Control-Allow-Origin: + - "*" + Content-Type: + - application/json; charset=utf-8 + Content-Length: + - '62' + Etag: + - W/"3e-3yNPCMU4MDQmKmieGPWfDcA/0Eg" + Date: + - Fri, 24 May 2024 01:48:44 GMT + Via: + - 1.1 vegur + body: + encoding: UTF-8 + string: '{"message":"User access denied","error":"User not authorized"}' + recorded_at: Fri, 24 May 2024 01:48:44 GMT +- request: + method: get + uri: https://login.lescommuns.org/auth/realms/data-food-consortium/.well-known/openid-configuration + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - SWD 2.0.3 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Date: + - Fri, 24 May 2024 01:48:46 GMT + Content-Type: + - application/json;charset=UTF-8 + Transfer-Encoding: + - chunked + Connection: + - keep-alive + Vary: + - Accept-Encoding + Set-Cookie: + - AUTH_SESSION_ID=1716515327.317.9431.725800|6055218c9898cae39f8ffd531999e49a; + Path=/; Secure; HttpOnly + Cache-Control: + - no-cache, must-revalidate, no-transform, no-store + Referrer-Policy: + - no-referrer + Strict-Transport-Security: + - max-age=15724800; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - 1; mode=block + body: + encoding: ASCII-8BIT + string: '{"issuer":"https://login.lescommuns.org/auth/realms/data-food-consortium","authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth","token_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token","introspection_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token/introspect","userinfo_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/userinfo","end_session_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/logout","frontchannel_logout_session_supported":true,"frontchannel_logout_supported":true,"jwks_uri":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/certs","check_session_iframe":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/login-status-iframe.html","grant_types_supported":["authorization_code","implicit","refresh_token","password","client_credentials","urn:openid:params:grant-type:ciba","urn:ietf:params:oauth:grant-type:device_code"],"acr_values_supported":["0","1"],"response_types_supported":["code","none","id_token","token","id_token + token","code id_token","code token","code id_token token"],"subject_types_supported":["public","pairwise"],"id_token_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"id_token_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"id_token_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"userinfo_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512","none"],"userinfo_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"userinfo_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"request_object_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512","none"],"request_object_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"request_object_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"response_modes_supported":["query","fragment","form_post","query.jwt","fragment.jwt","form_post.jwt","jwt"],"registration_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/clients-registrations/openid-connect","token_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"token_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"introspection_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"introspection_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"authorization_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"authorization_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"authorization_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"claims_supported":["aud","sub","iss","auth_time","name","given_name","family_name","preferred_username","email","acr"],"claim_types_supported":["normal"],"claims_parameter_supported":true,"scopes_supported":["openid","microprofile-jwt","phone","roles","profile","email","address","web-origins","acr","offline_access"],"request_parameter_supported":true,"request_uri_parameter_supported":true,"require_request_uri_registration":true,"code_challenge_methods_supported":["plain","S256"],"tls_client_certificate_bound_access_tokens":true,"revocation_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/revoke","revocation_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"revocation_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"backchannel_logout_supported":true,"backchannel_logout_session_supported":true,"device_authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth/device","backchannel_token_delivery_modes_supported":["poll","ping"],"backchannel_authentication_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/ciba/auth","backchannel_authentication_request_signing_alg_values_supported":["PS384","ES384","RS384","ES256","RS256","ES512","PS256","PS512","RS512"],"require_pushed_authorization_requests":false,"pushed_authorization_request_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/par/request","mtls_endpoint_aliases":{"token_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token","revocation_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/revoke","introspection_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token/introspect","device_authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth/device","registration_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/clients-registrations/openid-connect","userinfo_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/userinfo","pushed_authorization_request_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/par/request","backchannel_authentication_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/ciba/auth"},"authorization_response_iss_parameter_supported":true}' + recorded_at: Fri, 24 May 2024 01:48:46 GMT +- request: + method: post + uri: https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token + body: + encoding: UTF-8 + string: grant_type=refresh_token&refresh_token= + headers: + User-Agent: + - Rack::OAuth2 (2.2.1) + Authorization: + - "" + Content-Type: + - application/x-www-form-urlencoded + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Date: + - Fri, 24 May 2024 01:48:47 GMT + Content-Type: + - application/json + Transfer-Encoding: + - chunked + Connection: + - keep-alive + Vary: + - Accept-Encoding + Set-Cookie: + - AUTH_SESSION_ID=1716515328.538.9431.297717|6055218c9898cae39f8ffd531999e49a; + Path=/; Secure; HttpOnly + Cache-Control: + - no-store + Pragma: + - no-cache + Referrer-Policy: + - no-referrer + Strict-Transport-Security: + - max-age=15724800; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - 1; mode=block + body: + encoding: ASCII-8BIT + string: '{"access_token":"","expires_in":1800,"refresh_expires_in":31373710,"refresh_token":"","token_type":"Bearer","id_token":"","not-before-policy":0,"session_state":"cfaa4a60-c2aa-4590-9fdf-a117f23d564f","scope":"openid + profile email"}' + recorded_at: Fri, 24 May 2024 01:48:47 GMT +- request: + method: post + uri: https://food-data-collaboration-produc-fe870152f634.herokuapp.com/fdc/products?shop=test-hodmedod.myshopify.com + body: + encoding: UTF-8 + string: '{"userId":"testdfc@protonmail.com","accessToken":""}' + headers: + Content-Type: + - application/json + Authorization: + - "" + User-Agent: + - Faraday v2.9.0 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Server: + - Cowboy + Report-To: + - '{"group":"heroku-nel","max_age":3600,"endpoints":[{"url":"https://nel.heroku.com/reports?ts=1716515329&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=db8%2Bqll%2F9ViX4tDoArQRI69fIFO5okGU%2F86h1whY9lM%3D"}]}' + Reporting-Endpoints: + - heroku-nel=https://nel.heroku.com/reports?ts=1716515329&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=db8%2Bqll%2F9ViX4tDoArQRI69fIFO5okGU%2F86h1whY9lM%3D + Nel: + - '{"report_to":"heroku-nel","max_age":3600,"success_fraction":0.005,"failure_fraction":0.05,"response_headers":["Via"]}' + Connection: + - keep-alive + X-Powered-By: + - Express + Access-Control-Allow-Origin: + - "*" + Content-Type: + - application/json; charset=utf-8 + Content-Length: + - '41179' + Etag: + - W/"a0db-ySojxiWOF5gtH86VVAw3VoRbZ/o" + Date: + - Fri, 24 May 2024 01:48:49 GMT + Via: + - 1.1 vegur + body: + encoding: ASCII-8BIT + string: !binary |- + {"products":"{\"@context\":\"https://www.datafoodconsortium.org\",\"@graph\":[{\"@id\":\"_:b43\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b44\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"2.09\"},{\"@id\":\"_:b45\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b46\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"1.19\"},{\"@id\":\"_:b47\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.5\"},{\"@id\":\"_:b48\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"1.69\"},{\"@id\":\"_:b49\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b50\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"1.39\"},{\"@id\":\"_:b51\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.175\"},{\"@id\":\"_:b52\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"2.89\"},{\"@id\":\"_:b53\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b54\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"0.99\"},{\"@id\":\"_:b55\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.3\"},{\"@id\":\"_:b56\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"2.99\"},{\"@id\":\"_:b57\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b58\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"18.85\"},{\"@id\":\"_:b59\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b60\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"7.42\"},{\"@id\":\"_:b61\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"5\"},{\"@id\":\"_:b62\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"12.60\"},{\"@id\":\"_:b63\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b64\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"8.76\"},{\"@id\":\"_:b65\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"1.05\"},{\"@id\":\"_:b66\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"13.05\"},{\"@id\":\"_:b67\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b68\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"6.76\"},{\"@id\":\"_:b69\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"3\"},{\"@id\":\"_:b70\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"15.90\"},{\"@id\":\"_:b71\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b72\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b73\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b74\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b75\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"10\"},{\"@id\":\"_:b76\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b77\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b78\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b79\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"6\"},{\"@id\":\"_:b80\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b81\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b82\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b83\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"10\"},{\"@id\":\"_:b84\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>They're back!</strong></td>\\n</tr>\\n</tbody>\\n</table>\\n<p><strong>Think baked beans are British? They are now! We use only British-grown fava beans - Britain's original bean, grown here since the Iron Age. Our Baked British Beans are deliciously different, with large meaty fava beans in a tasty tomato sauce.</strong></p>\\n<p><strong><a title=\\\"What are fava beans? Aren't they just broad beans?\\\" href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\" data-mce-fragment=\\\"1\\\" data-mce-href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\">What are fava beans? Find out here...</a></strong></p>\\n<!-- split --><h3>Complete Product Details</h3><p>Our Baked British Beans are cooked and ready to eat, hot or cold. They're good served on toast but also delicious added to stews, curries or casseroles. Or even in a pie.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p><strong>Cooking on the Hob</strong><br>Empty contents into saucepan. Heat gently for 4-5 minutes while stirring. For best flavour do not boil or overcook. Do not reheat.</p>\\n<p><strong>Microwave Cooking</strong><br>Empty contents into a non-metallic bowl and cover. Heat for 2 to 3 minutes, stirring halfway. Check the food is hot, stir well and serve. Do not reheat.</p>\\n<h5 class=\\\"product-detail-title\\\">To Store</h5>\\n<p>Store in a cool, dry place. Once opened, transfer contents to a non-metallic container, cover refrigerate and use with 2 days.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Fava Beans (Broad Beans) (42%), Water, Tomato Puree, Sugar, Modified Maize Starch, Salt, Herbs &amp; Spices, Concentrated Lemon Juice</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>No Allergens</p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>292kJ (69kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>0.4g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.1g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>10.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>4.6g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.6g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Delicious, nutritious and good for the soil, fava beans are a variety of broad bean, Vicia faba, left to ripen and dry before harvest. They’re also known as field beans, horse beans, Windsor beans or ful.</p>\\n<p>Suitable for vegans and vegetarians</p>\\n\",\"dfc-b:hasQuantity\":\"_:b43\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_983x656_513758e6-2616-4687-a8b2-ba6dde864923.jpg?v=1677760778\",\"dfc-b:name\":\"Baked British Beans - Retail can, 400g (can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/offer\",\"dfc-b:sku\":\"NCBB/T4\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b44\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635\",\"dfc-b:hasQuantity\":\"_:b71\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b72\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>They're back!</strong></td>\\n</tr>\\n</tbody>\\n</table>\\n<p><strong>Think baked beans are British? They are now! We use only British-grown fava beans - Britain's original bean, grown here since the Iron Age. Our Baked British Beans are deliciously different, with large meaty fava beans in a tasty tomato sauce.</strong></p>\\n<p><strong><a title=\\\"What are fava beans? Aren't they just broad beans?\\\" href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\" data-mce-fragment=\\\"1\\\" data-mce-href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\">What are fava beans? Find out here...</a></strong></p>\\n<!-- split --><h3>Complete Product Details</h3><p>Our Baked British Beans are cooked and ready to eat, hot or cold. They're good served on toast but also delicious added to stews, curries or casseroles. Or even in a pie.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p><strong>Cooking on the Hob</strong><br>Empty contents into saucepan. Heat gently for 4-5 minutes while stirring. For best flavour do not boil or overcook. Do not reheat.</p>\\n<p><strong>Microwave Cooking</strong><br>Empty contents into a non-metallic bowl and cover. Heat for 2 to 3 minutes, stirring halfway. Check the food is hot, stir well and serve. Do not reheat.</p>\\n<h5 class=\\\"product-detail-title\\\">To Store</h5>\\n<p>Store in a cool, dry place. Once opened, transfer contents to a non-metallic container, cover refrigerate and use with 2 days.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Fava Beans (Broad Beans) (42%), Water, Tomato Puree, Sugar, Modified Maize Starch, Salt, Herbs &amp; Spices, Concentrated Lemon Juice</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>No Allergens</p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>292kJ (69kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>0.4g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.1g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>10.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>4.6g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.6g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Delicious, nutritious and good for the soil, fava beans are a variety of broad bean, Vicia faba, left to ripen and dry before harvest. They’re also known as field beans, horse beans, Windsor beans or ful.</p>\\n<p>Suitable for vegans and vegetarians</p>\\n\",\"dfc-b:hasQuantity\":\"_:b57\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_983x656_513758e6-2616-4687-a8b2-ba6dde864923.jpg?v=1677760778\",\"dfc-b:name\":\"Baked British Beans - Case, 12 x 400g (can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/offer\",\"dfc-b:sku\":\"NCBB/CD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b58\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>Sorry, standard barley flakes are no longer available but our delicious  Organic Naked Barley Flakes are back.</strong></td>\\n</tr>\\n</tbody>\\n</table><p>Our rich and malty barley flakes are a store cupboard staple. Organically grown and milled in the UK, they add texture to flapjack and biscuit recipes, or to make a heartier, rustic porridge – try blending with our other flakes</p>\\n<!-- split --><h3>Complete Product Details</h3><li id=\\\"tab1\\\" class=\\\"active\\\">\\n<p>Barley flakes are great added to muesli or granola, or used in baking as a topping or mixed into dough. Eat them as a cereal, bake with them, or add them to soups and stews to thicken, boost their nutrition and add flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>To eat as a muesli, combine with other cereal flakes and enjoy. Or use as an oat substitute in any baking recipe.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p><b>Barley </b>Flakes</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>For allergens, including cereals containing gluten, see ingredients in <strong>bold</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>1,401kJ (332kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>2.1g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.0g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>58.3g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>17.3g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>11.4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.0g</td>\\n</tr>\\n</tbody>\\n</table>\\n<h5 class=\\\"product-detail-title\\\">More</h5>\\n<ul>\\n<li>Suitable for vegans and vegetarians\\n</li>\\n<li>No artificial ingredients\\n</li>\\n<li>GM free\\n</li>\\n<li>High Fibre\\n</li>\\n</ul>\\n</li>\",\"dfc-b:hasQuantity\":\"_:b47\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Barley-Flakes-2400x1600_c121407c-6fd2-46ca-a124-db5df9442368.jpg?v=1677760781\",\"dfc-b:name\":\"Barley Flakes, Organic - Retail pack, 500g\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/offer\",\"dfc-b:sku\":\"OKBAR5\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b48\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171\",\"dfc-b:hasQuantity\":\"_:b75\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b76\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>Sorry, standard barley flakes are no longer available but our delicious  Organic Naked Barley Flakes are back.</strong></td>\\n</tr>\\n</tbody>\\n</table><p>Our rich and malty barley flakes are a store cupboard staple. Organically grown and milled in the UK, they add texture to flapjack and biscuit recipes, or to make a heartier, rustic porridge – try blending with our other flakes</p>\\n<!-- split --><h3>Complete Product Details</h3><li id=\\\"tab1\\\" class=\\\"active\\\">\\n<p>Barley flakes are great added to muesli or granola, or used in baking as a topping or mixed into dough. Eat them as a cereal, bake with them, or add them to soups and stews to thicken, boost their nutrition and add flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>To eat as a muesli, combine with other cereal flakes and enjoy. Or use as an oat substitute in any baking recipe.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p><b>Barley </b>Flakes</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>For allergens, including cereals containing gluten, see ingredients in <strong>bold</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>1,401kJ (332kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>2.1g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.0g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>58.3g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>17.3g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>11.4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.0g</td>\\n</tr>\\n</tbody>\\n</table>\\n<h5 class=\\\"product-detail-title\\\">More</h5>\\n<ul>\\n<li>Suitable for vegans and vegetarians\\n</li>\\n<li>No artificial ingredients\\n</li>\\n<li>GM free\\n</li>\\n<li>High Fibre\\n</li>\\n</ul>\\n</li>\",\"dfc-b:hasQuantity\":\"_:b61\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Barley-Flakes-2400x1600_c121407c-6fd2-46ca-a124-db5df9442368.jpg?v=1677760781\",\"dfc-b:name\":\"Barley Flakes, Organic - Standard case, 10 x 500g\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/offer\",\"dfc-b:sku\":\"OKBACX\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b62\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<p><strong>Fermented wholegrain naked barley, tasty and succulent grains of rich malty umami flavour.</strong></p>\\n<p>These whole fermented barley grains are packed with deep flavour and make a delicious addition to bread, risotto, stews, salads and more.</p>\\n<!-- split --><h3>Complete Product Details</h3>\\n<p>Add intensely flavoured malty and succulent grains full of umami richness to breads, risotto, stews, soups, and even salads.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>Add about half a teaspoon per serving to almost any dish for added depth, umami richness and malty flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">To store</h5>\\n<p>Keep refrigerated and use within 4 weeks of opening.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Naked <strong>Barley</strong>, Water, <strong>Wheat</strong> Flour, Salt, Live Cultures*<br> *<em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em>, <em>Zygosaccharomyces rouxii</em></p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>Contains <strong>Barley (Gluten)</strong>,<strong> Wheat (Gluten)</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>500kJ (119kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.5g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>19.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>2.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5.2g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4.2g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>8.5g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Our Fermented Wholegrain Naked Barley is fermented in the same way as many soya ferments used for black beans, but using naked barley grain instead of soy beans. It's made with just naked barley grains, water and salt, fermented with a live culture of <em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em> and <em>Zygosaccharomyces rouxii</em>.</p>\\n<p>Suitable for vegans.</p>\\n<p>Packed in recyclable glass jar with metal lid.</p>\",\"dfc-b:hasQuantity\":\"_:b51\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Fermented-Wholegrain-Naked-Barley-Spoon-1600x1000_d6fea092-fde4-4a98-bec8-bb3ca0a1fd4d.jpg?v=1677760860\",\"dfc-b:name\":\"Fermented Naked Barley - Retail jar, 175g (jar)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/offer\",\"dfc-b:sku\":\"NMNB/JF\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b52\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915\",\"dfc-b:hasQuantity\":\"_:b79\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b80\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<p><strong>Fermented wholegrain naked barley, tasty and succulent grains of rich malty umami flavour.</strong></p>\\n<p>These whole fermented barley grains are packed with deep flavour and make a delicious addition to bread, risotto, stews, salads and more.</p>\\n<!-- split --><h3>Complete Product Details</h3>\\n<p>Add intensely flavoured malty and succulent grains full of umami richness to breads, risotto, stews, soups, and even salads.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>Add about half a teaspoon per serving to almost any dish for added depth, umami richness and malty flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">To store</h5>\\n<p>Keep refrigerated and use within 4 weeks of opening.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Naked <strong>Barley</strong>, Water, <strong>Wheat</strong> Flour, Salt, Live Cultures*<br> *<em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em>, <em>Zygosaccharomyces rouxii</em></p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>Contains <strong>Barley (Gluten)</strong>,<strong> Wheat (Gluten)</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>500kJ (119kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.5g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>19.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>2.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5.2g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4.2g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>8.5g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Our Fermented Wholegrain Naked Barley is fermented in the same way as many soya ferments used for black beans, but using naked barley grain instead of soy beans. It's made with just naked barley grains, water and salt, fermented with a live culture of <em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em> and <em>Zygosaccharomyces rouxii</em>.</p>\\n<p>Suitable for vegans.</p>\\n<p>Packed in recyclable glass jar with metal lid.</p>\",\"dfc-b:hasQuantity\":\"_:b65\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Fermented-Wholegrain-Naked-Barley-Spoon-1600x1000_d6fea092-fde4-4a98-bec8-bb3ca0a1fd4d.jpg?v=1677760860\",\"dfc-b:name\":\"Fermented Naked Barley - Case, 6 x 175g (jar)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/offer\",\"dfc-b:sku\":\"NMNB/C6\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b66\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b59\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_a4d58459-bf52-48a9-bae7-807f4035b87f.jpg?v=1677760777\",\"dfc-b:name\":\"Baked British Beans (ToL) - Case - 12 x 400g cans\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/offer\",\"dfc-b:sku\":\"NCBBCD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b60\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b45\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_a4d58459-bf52-48a9-bae7-807f4035b87f.jpg?v=1677760777\",\"dfc-b:name\":\"Baked British Beans (ToL) - Single - 400g can\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/offer\",\"dfc-b:sku\":\"NCBBT4\",\"dfc-b:stockLimitation\":\"20\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b46\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619\",\"dfc-b:hasQuantity\":\"_:b73\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b74\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b67\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Whole-Fava-Beans-Organic-Canned_fcb64fd7-8ca3-465a-8f56-443cf28e0b71.jpg?v=1677760977\",\"dfc-b:name\":\"Organic Whole Fava Beans in Water (ToL) - Case - 12 x 400g cans\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/offer\",\"dfc-b:sku\":\"OCFBCD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b68\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b53\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Whole-Fava-Beans-Organic-Canned_fcb64fd7-8ca3-465a-8f56-443cf28e0b71.jpg?v=1677760977\",\"dfc-b:name\":\"Organic Whole Fava Beans in Water (ToL) - Single - 400g can\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/offer\",\"dfc-b:sku\":\"OCFBT4\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b54\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715\",\"dfc-b:hasQuantity\":\"_:b81\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b82\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b49\",\"dfc-b:name\":\"Carlin Peas in Water, Organic (DISTRIBUTOR) - Retail can (400g can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/offer\",\"dfc-b:sku\":\"OCCPT4\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b50\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075\",\"dfc-b:hasQuantity\":\"_:b77\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b78\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b63\",\"dfc-b:name\":\"Carlin Peas in Water, Organic (DISTRIBUTOR) - Standard case (12 x 400g can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/offer\",\"dfc-b:sku\":\"OCCPCD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b64\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b55\",\"dfc-b:name\":\"Roasted Fava Beans, Lightly Sea Salted (DISTRIBUTOR) - Retail pack (300g)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/offer\",\"dfc-b:sku\":\"NRFSR3\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b56\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563\",\"dfc-b:hasQuantity\":\"_:b83\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b84\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b69\",\"dfc-b:name\":\"Roasted Fava Beans, Lightly Sea Salted (DISTRIBUTOR) - Standard case (10 x 300g)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/offer\",\"dfc-b:sku\":\"NRFSCX\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b70\"}}]}","lastId":"8147292258611","remainingProductsCountAfter":0,"success":true,"message":"Products retrieved successfully"} + recorded_at: Fri, 24 May 2024 01:48:50 GMT +recorded_with: VCR 6.2.0 diff --git a/spec/support/vcr_setup.rb b/spec/support/vcr_setup.rb index 5d5c155e27..bf2574a0b3 100644 --- a/spec/support/vcr_setup.rb +++ b/spec/support/vcr_setup.rb @@ -40,4 +40,9 @@ VCR.configure do |config| config.filter_sensitive_data('') { |interaction| interaction.response.body.match(/"refresh_token":"([^"]+)"/)&.public_send(:[], 1) } + + # FDC specific parameter: + config.filter_sensitive_data('') { |interaction| + interaction.request.body.match(/"accessToken":"([^"]+)"/)&.public_send(:[], 1) + } end From a1992aed7ca5215939f8c83ba010032d8cc02f43 Mon Sep 17 00:00:00 2001 From: Maikel Linke Date: Tue, 28 May 2024 15:13:18 +1000 Subject: [PATCH 4/5] Handle string values for variant unit value The FDC API is returning all values as strings. This should probably be handled in the Connector long-term. --- .../app/services/quantitative_value_builder.rb | 2 +- .../services/quantitative_value_builder_spec.rb | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/engines/dfc_provider/app/services/quantitative_value_builder.rb b/engines/dfc_provider/app/services/quantitative_value_builder.rb index 3779463115..6baac1eecf 100644 --- a/engines/dfc_provider/app/services/quantitative_value_builder.rb +++ b/engines/dfc_provider/app/services/quantitative_value_builder.rb @@ -33,7 +33,7 @@ class QuantitativeValueBuilder < DfcBuilder product.variant_unit = measure product.variant_unit_name = unit_name if measure == "items" product.variant_unit_scale = unit_scale - product.unit_value = quantity.value * unit_scale + product.unit_value = quantity.value.to_f * unit_scale end # Map DFC units to OFN fields: diff --git a/engines/dfc_provider/spec/services/quantitative_value_builder_spec.rb b/engines/dfc_provider/spec/services/quantitative_value_builder_spec.rb index 4c5403e7e7..f18a58b561 100644 --- a/engines/dfc_provider/spec/services/quantitative_value_builder_spec.rb +++ b/engines/dfc_provider/spec/services/quantitative_value_builder_spec.rb @@ -104,6 +104,20 @@ RSpec.describe QuantitativeValueBuilder do expect(product.unit_value).to eq 0.005 end + it "interpretes values given as a string" do + quantity = DataFoodConsortium::Connector::QuantitativeValue.new( + unit: quantity_unit.KILOGRAM, + value: "0.4", + ) + + builder.apply(quantity, product) + + expect(product.variant_unit).to eq "weight" + expect(product.variant_unit_name).to eq nil + expect(product.variant_unit_scale).to eq 1_000 + expect(product.unit_value).to eq 400 + end + it "knows imperial units" do quantity = DataFoodConsortium::Connector::QuantitativeValue.new( unit: quantity_unit.POUNDMASS, From fae7a089ee329e92b42898237c60cad22aa5881c Mon Sep 17 00:00:00 2001 From: Maikel Linke Date: Fri, 24 May 2024 16:52:35 +1000 Subject: [PATCH 5/5] Import products from the FDC (Shopify) API --- .../admin/dfc_product_imports_controller.rb | 12 +- .../imports_from_a_FDC_catalog.yml | 206 ++++++++++++++++++ spec/system/admin/dfc_product_import_spec.rb | 23 ++ 3 files changed, 240 insertions(+), 1 deletion(-) create mode 100644 spec/fixtures/vcr_cassettes/DFC_Product_Import/imports_from_a_FDC_catalog.yml diff --git a/app/controllers/admin/dfc_product_imports_controller.rb b/app/controllers/admin/dfc_product_imports_controller.rb index 8dc580afbd..c1076ea775 100644 --- a/app/controllers/admin/dfc_product_imports_controller.rb +++ b/app/controllers/admin/dfc_product_imports_controller.rb @@ -20,7 +20,7 @@ module Admin catalog_url = params.require(:catalog_url) - json_catalog = DfcRequest.new(spree_current_user).call(catalog_url) + json_catalog = fetch_catalog(catalog_url) graph = DfcIo.import(json_catalog) # * First step: import all products for given enterprise. @@ -34,6 +34,16 @@ module Admin private + def fetch_catalog(url) + if url =~ /food-data-collaboration/ + fdc_json = FdcRequest.new(spree_current_user).call(url) + fdc_message = JSON.parse(fdc_json) + fdc_message["products"] + else + DfcRequest.new(spree_current_user).call(url) + end + end + # Most of this code is the same as in the DfcProvider::SuppliedProductsController. def import_product(subject, enterprise) return unless subject.is_a? DataFoodConsortium::Connector::SuppliedProduct diff --git a/spec/fixtures/vcr_cassettes/DFC_Product_Import/imports_from_a_FDC_catalog.yml b/spec/fixtures/vcr_cassettes/DFC_Product_Import/imports_from_a_FDC_catalog.yml new file mode 100644 index 0000000000..ad4af0b09b --- /dev/null +++ b/spec/fixtures/vcr_cassettes/DFC_Product_Import/imports_from_a_FDC_catalog.yml @@ -0,0 +1,206 @@ +--- +http_interactions: +- request: + method: post + uri: https://food-data-collaboration-produc-fe870152f634.herokuapp.com/fdc/products?shop=test-hodmedod.myshopify.com + body: + encoding: UTF-8 + string: '{"userId":"testdfc@protonmail.com","accessToken":""}' + headers: + Content-Type: + - application/json + Authorization: + - "" + User-Agent: + - Faraday v2.9.0 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 403 + message: Forbidden + headers: + Server: + - Cowboy + Report-To: + - '{"group":"heroku-nel","max_age":3600,"endpoints":[{"url":"https://nel.heroku.com/reports?ts=1716531220&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=GSiP%2FtCyGGyQZrjxJKzy4%2F8ZDbqeNOf8qWTTKv61%2FjQ%3D"}]}' + Reporting-Endpoints: + - heroku-nel=https://nel.heroku.com/reports?ts=1716531220&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=GSiP%2FtCyGGyQZrjxJKzy4%2F8ZDbqeNOf8qWTTKv61%2FjQ%3D + Nel: + - '{"report_to":"heroku-nel","max_age":3600,"success_fraction":0.005,"failure_fraction":0.05,"response_headers":["Via"]}' + Connection: + - keep-alive + X-Powered-By: + - Express + Access-Control-Allow-Origin: + - "*" + Content-Type: + - application/json; charset=utf-8 + Content-Length: + - '62' + Etag: + - W/"3e-3yNPCMU4MDQmKmieGPWfDcA/0Eg" + Date: + - Fri, 24 May 2024 06:13:41 GMT + Via: + - 1.1 vegur + body: + encoding: UTF-8 + string: '{"message":"User access denied","error":"User not authorized"}' + recorded_at: Fri, 24 May 2024 06:13:41 GMT +- request: + method: get + uri: https://login.lescommuns.org/auth/realms/data-food-consortium/.well-known/openid-configuration + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - SWD 2.0.3 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Date: + - Fri, 24 May 2024 06:13:42 GMT + Content-Type: + - application/json;charset=UTF-8 + Transfer-Encoding: + - chunked + Connection: + - keep-alive + Vary: + - Accept-Encoding + Set-Cookie: + - AUTH_SESSION_ID=1716531223.827.7041.811327|6055218c9898cae39f8ffd531999e49a; + Path=/; Secure; HttpOnly + Cache-Control: + - no-cache, must-revalidate, no-transform, no-store + Referrer-Policy: + - no-referrer + Strict-Transport-Security: + - max-age=15724800; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - 1; mode=block + body: + encoding: ASCII-8BIT + string: '{"issuer":"https://login.lescommuns.org/auth/realms/data-food-consortium","authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth","token_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token","introspection_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token/introspect","userinfo_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/userinfo","end_session_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/logout","frontchannel_logout_session_supported":true,"frontchannel_logout_supported":true,"jwks_uri":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/certs","check_session_iframe":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/login-status-iframe.html","grant_types_supported":["authorization_code","implicit","refresh_token","password","client_credentials","urn:openid:params:grant-type:ciba","urn:ietf:params:oauth:grant-type:device_code"],"acr_values_supported":["0","1"],"response_types_supported":["code","none","id_token","token","id_token + token","code id_token","code token","code id_token token"],"subject_types_supported":["public","pairwise"],"id_token_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"id_token_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"id_token_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"userinfo_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512","none"],"userinfo_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"userinfo_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"request_object_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512","none"],"request_object_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"request_object_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"response_modes_supported":["query","fragment","form_post","query.jwt","fragment.jwt","form_post.jwt","jwt"],"registration_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/clients-registrations/openid-connect","token_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"token_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"introspection_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"introspection_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"authorization_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"authorization_encryption_alg_values_supported":["RSA-OAEP","RSA-OAEP-256","RSA1_5"],"authorization_encryption_enc_values_supported":["A256GCM","A192GCM","A128GCM","A128CBC-HS256","A192CBC-HS384","A256CBC-HS512"],"claims_supported":["aud","sub","iss","auth_time","name","given_name","family_name","preferred_username","email","acr"],"claim_types_supported":["normal"],"claims_parameter_supported":true,"scopes_supported":["openid","microprofile-jwt","phone","roles","profile","email","address","web-origins","acr","offline_access"],"request_parameter_supported":true,"request_uri_parameter_supported":true,"require_request_uri_registration":true,"code_challenge_methods_supported":["plain","S256"],"tls_client_certificate_bound_access_tokens":true,"revocation_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/revoke","revocation_endpoint_auth_methods_supported":["private_key_jwt","client_secret_basic","client_secret_post","tls_client_auth","client_secret_jwt"],"revocation_endpoint_auth_signing_alg_values_supported":["PS384","ES384","RS384","HS256","HS512","ES256","RS256","HS384","ES512","PS256","PS512","RS512"],"backchannel_logout_supported":true,"backchannel_logout_session_supported":true,"device_authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth/device","backchannel_token_delivery_modes_supported":["poll","ping"],"backchannel_authentication_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/ciba/auth","backchannel_authentication_request_signing_alg_values_supported":["PS384","ES384","RS384","ES256","RS256","ES512","PS256","PS512","RS512"],"require_pushed_authorization_requests":false,"pushed_authorization_request_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/par/request","mtls_endpoint_aliases":{"token_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token","revocation_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/revoke","introspection_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token/introspect","device_authorization_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/auth/device","registration_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/clients-registrations/openid-connect","userinfo_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/userinfo","pushed_authorization_request_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/par/request","backchannel_authentication_endpoint":"https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/ext/ciba/auth"},"authorization_response_iss_parameter_supported":true}' + recorded_at: Fri, 24 May 2024 06:13:43 GMT +- request: + method: post + uri: https://login.lescommuns.org/auth/realms/data-food-consortium/protocol/openid-connect/token + body: + encoding: UTF-8 + string: grant_type=refresh_token&refresh_token= + headers: + User-Agent: + - Rack::OAuth2 (2.2.1) + Authorization: + - "" + Content-Type: + - application/x-www-form-urlencoded + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Date: + - Fri, 24 May 2024 06:13:44 GMT + Content-Type: + - application/json + Transfer-Encoding: + - chunked + Connection: + - keep-alive + Vary: + - Accept-Encoding + Set-Cookie: + - AUTH_SESSION_ID=1716531225.15.7041.192535|6055218c9898cae39f8ffd531999e49a; + Path=/; Secure; HttpOnly + Cache-Control: + - no-store + Pragma: + - no-cache + Referrer-Policy: + - no-referrer + Strict-Transport-Security: + - max-age=15724800; includeSubDomains + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - 1; mode=block + body: + encoding: ASCII-8BIT + string: '{"access_token":"","expires_in":1800,"refresh_expires_in":31357813,"refresh_token":"","token_type":"Bearer","id_token":"","not-before-policy":0,"session_state":"cfaa4a60-c2aa-4590-9fdf-a117f23d564f","scope":"openid + profile email"}' + recorded_at: Fri, 24 May 2024 06:13:44 GMT +- request: + method: post + uri: https://food-data-collaboration-produc-fe870152f634.herokuapp.com/fdc/products?shop=test-hodmedod.myshopify.com + body: + encoding: UTF-8 + string: '{"userId":"testdfc@protonmail.com","accessToken":""}' + headers: + Content-Type: + - application/json + Authorization: + - "" + User-Agent: + - Faraday v2.9.0 + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Server: + - Cowboy + Report-To: + - '{"group":"heroku-nel","max_age":3600,"endpoints":[{"url":"https://nel.heroku.com/reports?ts=1716531225&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=zHpdjRNvPwW4u7pYofDRsdOcjztCveqnM3K9GcGjhMU%3D"}]}' + Reporting-Endpoints: + - heroku-nel=https://nel.heroku.com/reports?ts=1716531225&sid=812dcc77-0bd0-43b1-a5f1-b25750382959&s=zHpdjRNvPwW4u7pYofDRsdOcjztCveqnM3K9GcGjhMU%3D + Nel: + - '{"report_to":"heroku-nel","max_age":3600,"success_fraction":0.005,"failure_fraction":0.05,"response_headers":["Via"]}' + Connection: + - keep-alive + X-Powered-By: + - Express + Access-Control-Allow-Origin: + - "*" + Content-Type: + - application/json; charset=utf-8 + Content-Length: + - '41161' + Etag: + - W/"a0c9-f4oAeN9fidSaWKNQXG3R8vniAac" + Date: + - Fri, 24 May 2024 06:13:49 GMT + Via: + - 1.1 vegur + body: + encoding: ASCII-8BIT + string: !binary |- + {"products":"{\"@context\":\"https://www.datafoodconsortium.org\",\"@graph\":[{\"@id\":\"_:b1\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b10\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"2.89\"},{\"@id\":\"_:b11\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b12\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"0.99\"},{\"@id\":\"_:b13\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.3\"},{\"@id\":\"_:b14\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"2.99\"},{\"@id\":\"_:b15\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b16\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"18.85\"},{\"@id\":\"_:b17\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b18\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"7.42\"},{\"@id\":\"_:b19\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"5\"},{\"@id\":\"_:b2\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"2.09\"},{\"@id\":\"_:b20\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"12.60\"},{\"@id\":\"_:b21\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b22\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"8.76\"},{\"@id\":\"_:b23\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"1.05\"},{\"@id\":\"_:b24\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"13.05\"},{\"@id\":\"_:b25\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"4.8\"},{\"@id\":\"_:b26\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"6.76\"},{\"@id\":\"_:b27\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"3\"},{\"@id\":\"_:b28\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"15.90\"},{\"@id\":\"_:b29\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b3\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b30\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b31\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b32\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b33\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"10\"},{\"@id\":\"_:b34\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b35\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b36\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b37\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"6\"},{\"@id\":\"_:b38\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b39\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"12\"},{\"@id\":\"_:b4\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"1.19\"},{\"@id\":\"_:b40\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b41\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"10\"},{\"@id\":\"_:b42\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Piece\",\"dfc-b:value\":\"1\"},{\"@id\":\"_:b5\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.5\"},{\"@id\":\"_:b6\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"1.69\"},{\"@id\":\"_:b7\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.4\"},{\"@id\":\"_:b8\",\"@type\":\"dfc-b:Price\",\"dfc-b:VATrate\":\"0\",\"dfc-b:hasUnit\":\"dfc-m:Euro\",\"dfc-b:value\":\"1.39\"},{\"@id\":\"_:b9\",\"@type\":\"dfc-b:QuantitativeValue\",\"dfc-b:hasUnit\":\"dfc-m:Kilogram\",\"dfc-b:value\":\"0.175\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>They're back!</strong></td>\\n</tr>\\n</tbody>\\n</table>\\n<p><strong>Think baked beans are British? They are now! We use only British-grown fava beans - Britain's original bean, grown here since the Iron Age. Our Baked British Beans are deliciously different, with large meaty fava beans in a tasty tomato sauce.</strong></p>\\n<p><strong><a title=\\\"What are fava beans? Aren't they just broad beans?\\\" href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\" data-mce-fragment=\\\"1\\\" data-mce-href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\">What are fava beans? Find out here...</a></strong></p>\\n<!-- split --><h3>Complete Product Details</h3><p>Our Baked British Beans are cooked and ready to eat, hot or cold. They're good served on toast but also delicious added to stews, curries or casseroles. Or even in a pie.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p><strong>Cooking on the Hob</strong><br>Empty contents into saucepan. Heat gently for 4-5 minutes while stirring. For best flavour do not boil or overcook. Do not reheat.</p>\\n<p><strong>Microwave Cooking</strong><br>Empty contents into a non-metallic bowl and cover. Heat for 2 to 3 minutes, stirring halfway. Check the food is hot, stir well and serve. Do not reheat.</p>\\n<h5 class=\\\"product-detail-title\\\">To Store</h5>\\n<p>Store in a cool, dry place. Once opened, transfer contents to a non-metallic container, cover refrigerate and use with 2 days.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Fava Beans (Broad Beans) (42%), Water, Tomato Puree, Sugar, Modified Maize Starch, Salt, Herbs &amp; Spices, Concentrated Lemon Juice</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>No Allergens</p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>292kJ (69kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>0.4g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.1g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>10.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>4.6g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.6g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Delicious, nutritious and good for the soil, fava beans are a variety of broad bean, Vicia faba, left to ripen and dry before harvest. They’re also known as field beans, horse beans, Windsor beans or ful.</p>\\n<p>Suitable for vegans and vegetarians</p>\\n\",\"dfc-b:hasQuantity\":\"_:b1\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_983x656_513758e6-2616-4687-a8b2-ba6dde864923.jpg?v=1677760778\",\"dfc-b:name\":\"Baked British Beans - Retail can, 400g (can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/offer\",\"dfc-b:sku\":\"NCBB/T4\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b2\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635\",\"dfc-b:hasQuantity\":\"_:b29\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b30\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466467635/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>They're back!</strong></td>\\n</tr>\\n</tbody>\\n</table>\\n<p><strong>Think baked beans are British? They are now! We use only British-grown fava beans - Britain's original bean, grown here since the Iron Age. Our Baked British Beans are deliciously different, with large meaty fava beans in a tasty tomato sauce.</strong></p>\\n<p><strong><a title=\\\"What are fava beans? Aren't they just broad beans?\\\" href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\" data-mce-fragment=\\\"1\\\" data-mce-href=\\\"/blogs/news/what-are-fava-beans-are-they-just-broad-beans\\\">What are fava beans? Find out here...</a></strong></p>\\n<!-- split --><h3>Complete Product Details</h3><p>Our Baked British Beans are cooked and ready to eat, hot or cold. They're good served on toast but also delicious added to stews, curries or casseroles. Or even in a pie.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p><strong>Cooking on the Hob</strong><br>Empty contents into saucepan. Heat gently for 4-5 minutes while stirring. For best flavour do not boil or overcook. Do not reheat.</p>\\n<p><strong>Microwave Cooking</strong><br>Empty contents into a non-metallic bowl and cover. Heat for 2 to 3 minutes, stirring halfway. Check the food is hot, stir well and serve. Do not reheat.</p>\\n<h5 class=\\\"product-detail-title\\\">To Store</h5>\\n<p>Store in a cool, dry place. Once opened, transfer contents to a non-metallic container, cover refrigerate and use with 2 days.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Fava Beans (Broad Beans) (42%), Water, Tomato Puree, Sugar, Modified Maize Starch, Salt, Herbs &amp; Spices, Concentrated Lemon Juice</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>No Allergens</p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>292kJ (69kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>0.4g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.1g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>10.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>4.6g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.6g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Delicious, nutritious and good for the soil, fava beans are a variety of broad bean, Vicia faba, left to ripen and dry before harvest. They’re also known as field beans, horse beans, Windsor beans or ful.</p>\\n<p>Suitable for vegans and vegetarians</p>\\n\",\"dfc-b:hasQuantity\":\"_:b15\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_983x656_513758e6-2616-4687-a8b2-ba6dde864923.jpg?v=1677760778\",\"dfc-b:name\":\"Baked British Beans - Case, 12 x 400g (can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/offer\",\"dfc-b:sku\":\"NCBB/CD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466500403/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b16\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>Sorry, standard barley flakes are no longer available but our delicious  Organic Naked Barley Flakes are back.</strong></td>\\n</tr>\\n</tbody>\\n</table><p>Our rich and malty barley flakes are a store cupboard staple. Organically grown and milled in the UK, they add texture to flapjack and biscuit recipes, or to make a heartier, rustic porridge – try blending with our other flakes</p>\\n<!-- split --><h3>Complete Product Details</h3><li id=\\\"tab1\\\" class=\\\"active\\\">\\n<p>Barley flakes are great added to muesli or granola, or used in baking as a topping or mixed into dough. Eat them as a cereal, bake with them, or add them to soups and stews to thicken, boost their nutrition and add flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>To eat as a muesli, combine with other cereal flakes and enjoy. Or use as an oat substitute in any baking recipe.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p><b>Barley </b>Flakes</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>For allergens, including cereals containing gluten, see ingredients in <strong>bold</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>1,401kJ (332kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>2.1g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.0g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>58.3g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>17.3g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>11.4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.0g</td>\\n</tr>\\n</tbody>\\n</table>\\n<h5 class=\\\"product-detail-title\\\">More</h5>\\n<ul>\\n<li>Suitable for vegans and vegetarians\\n</li>\\n<li>No artificial ingredients\\n</li>\\n<li>GM free\\n</li>\\n<li>High Fibre\\n</li>\\n</ul>\\n</li>\",\"dfc-b:hasQuantity\":\"_:b5\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Barley-Flakes-2400x1600_c121407c-6fd2-46ca-a124-db5df9442368.jpg?v=1677760781\",\"dfc-b:name\":\"Barley Flakes, Organic - Retail pack, 500g\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/offer\",\"dfc-b:sku\":\"OKBAR5\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b6\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171\",\"dfc-b:hasQuantity\":\"_:b33\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b34\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466533171/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<table width=\\\"100%\\\">\\n<tbody>\\n<tr style=\\\"border: 0px;\\\">\\n<td bgcolor=\\\"#d6fbed\\\" style=\\\"color: #000000; border: 0px;\\\"><strong>Sorry, standard barley flakes are no longer available but our delicious  Organic Naked Barley Flakes are back.</strong></td>\\n</tr>\\n</tbody>\\n</table><p>Our rich and malty barley flakes are a store cupboard staple. Organically grown and milled in the UK, they add texture to flapjack and biscuit recipes, or to make a heartier, rustic porridge – try blending with our other flakes</p>\\n<!-- split --><h3>Complete Product Details</h3><li id=\\\"tab1\\\" class=\\\"active\\\">\\n<p>Barley flakes are great added to muesli or granola, or used in baking as a topping or mixed into dough. Eat them as a cereal, bake with them, or add them to soups and stews to thicken, boost their nutrition and add flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>To eat as a muesli, combine with other cereal flakes and enjoy. Or use as an oat substitute in any baking recipe.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p><b>Barley </b>Flakes</p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>For allergens, including cereals containing gluten, see ingredients in <strong>bold</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>1,401kJ (332kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>2.1g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.0g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>58.3g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>17.3g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>11.4g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>0.0g</td>\\n</tr>\\n</tbody>\\n</table>\\n<h5 class=\\\"product-detail-title\\\">More</h5>\\n<ul>\\n<li>Suitable for vegans and vegetarians\\n</li>\\n<li>No artificial ingredients\\n</li>\\n<li>GM free\\n</li>\\n<li>High Fibre\\n</li>\\n</ul>\\n</li>\",\"dfc-b:hasQuantity\":\"_:b19\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Barley-Flakes-2400x1600_c121407c-6fd2-46ca-a124-db5df9442368.jpg?v=1677760781\",\"dfc-b:name\":\"Barley Flakes, Organic - Standard case, 10 x 500g\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/offer\",\"dfc-b:sku\":\"OKBACX\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519466565939/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b20\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<p><strong>Fermented wholegrain naked barley, tasty and succulent grains of rich malty umami flavour.</strong></p>\\n<p>These whole fermented barley grains are packed with deep flavour and make a delicious addition to bread, risotto, stews, salads and more.</p>\\n<!-- split --><h3>Complete Product Details</h3>\\n<p>Add intensely flavoured malty and succulent grains full of umami richness to breads, risotto, stews, soups, and even salads.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>Add about half a teaspoon per serving to almost any dish for added depth, umami richness and malty flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">To store</h5>\\n<p>Keep refrigerated and use within 4 weeks of opening.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Naked <strong>Barley</strong>, Water, <strong>Wheat</strong> Flour, Salt, Live Cultures*<br> *<em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em>, <em>Zygosaccharomyces rouxii</em></p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>Contains <strong>Barley (Gluten)</strong>,<strong> Wheat (Gluten)</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>500kJ (119kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.5g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>19.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>2.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5.2g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4.2g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>8.5g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Our Fermented Wholegrain Naked Barley is fermented in the same way as many soya ferments used for black beans, but using naked barley grain instead of soy beans. It's made with just naked barley grains, water and salt, fermented with a live culture of <em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em> and <em>Zygosaccharomyces rouxii</em>.</p>\\n<p>Suitable for vegans.</p>\\n<p>Packed in recyclable glass jar with metal lid.</p>\",\"dfc-b:hasQuantity\":\"_:b9\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Fermented-Wholegrain-Naked-Barley-Spoon-1600x1000_d6fea092-fde4-4a98-bec8-bb3ca0a1fd4d.jpg?v=1677760860\",\"dfc-b:name\":\"Fermented Naked Barley - Retail jar, 175g (jar)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/offer\",\"dfc-b:sku\":\"NMNB/JF\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b10\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915\",\"dfc-b:hasQuantity\":\"_:b37\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b38\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473348915/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:description\":\"<p><strong>Fermented wholegrain naked barley, tasty and succulent grains of rich malty umami flavour.</strong></p>\\n<p>These whole fermented barley grains are packed with deep flavour and make a delicious addition to bread, risotto, stews, salads and more.</p>\\n<!-- split --><h3>Complete Product Details</h3>\\n<p>Add intensely flavoured malty and succulent grains full of umami richness to breads, risotto, stews, soups, and even salads.</p>\\n<h5 class=\\\"product-detail-title\\\">Cooking instructions</h5>\\n<p>Add about half a teaspoon per serving to almost any dish for added depth, umami richness and malty flavour.</p>\\n<h5 class=\\\"product-detail-title\\\">To store</h5>\\n<p>Keep refrigerated and use within 4 weeks of opening.</p>\\n<h5 class=\\\"product-detail-title\\\">Ingredients</h5>\\n<p>Naked <strong>Barley</strong>, Water, <strong>Wheat</strong> Flour, Salt, Live Cultures*<br> *<em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em>, <em>Zygosaccharomyces rouxii</em></p>\\n<h5 class=\\\"product-detail-title\\\">Allergy information</h5>\\n<p>Contains <strong>Barley (Gluten)</strong>,<strong> Wheat (Gluten)</strong></p>\\n<table width=\\\"100%\\\">\\n<tbody>\\n<tr>\\n<td><strong>Typical values</strong></td>\\n<td><strong>Per 100g</strong></td>\\n</tr>\\n<tr>\\n<td>Energy</td>\\n<td>500kJ (119kcal)</td>\\n</tr>\\n<tr>\\n<td>Fat</td>\\n<td>1.7g</td>\\n</tr>\\n<tr>\\n<td>of which saturates</td>\\n<td>0.5g</td>\\n</tr>\\n<tr>\\n<td>Carbohydrate</td>\\n<td>19.1g</td>\\n</tr>\\n<tr>\\n<td>of which sugars</td>\\n<td>2.7g</td>\\n</tr>\\n<tr>\\n<td>Fibre</td>\\n<td>5.2g</td>\\n</tr>\\n<tr>\\n<td>Protein</td>\\n<td>4.2g</td>\\n</tr>\\n<tr>\\n<td>Salt</td>\\n<td>8.5g</td>\\n</tr>\\n</tbody>\\n</table><h5 class=\\\"product-detail-title\\\">More</h5>\\n<p>Our Fermented Wholegrain Naked Barley is fermented in the same way as many soya ferments used for black beans, but using naked barley grain instead of soy beans. It's made with just naked barley grains, water and salt, fermented with a live culture of <em>Lactobacillus delbrueckii</em>, <em>Aspergillus sojae</em> and <em>Zygosaccharomyces rouxii</em>.</p>\\n<p>Suitable for vegans.</p>\\n<p>Packed in recyclable glass jar with metal lid.</p>\",\"dfc-b:hasQuantity\":\"_:b23\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Fermented-Wholegrain-Naked-Barley-Spoon-1600x1000_d6fea092-fde4-4a98-bec8-bb3ca0a1fd4d.jpg?v=1677760860\",\"dfc-b:name\":\"Fermented Naked Barley - Case, 6 x 175g (jar)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/offer\",\"dfc-b:sku\":\"NMNB/C6\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44519473381683/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b24\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b17\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_a4d58459-bf52-48a9-bae7-807f4035b87f.jpg?v=1677760777\",\"dfc-b:name\":\"Baked British Beans (ToL) - Case - 12 x 400g cans\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/offer\",\"dfc-b:sku\":\"NCBBCD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b18\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b3\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Pack-Can-Baked-Beans-1800x6_a4d58459-bf52-48a9-bae7-807f4035b87f.jpg?v=1677760777\",\"dfc-b:name\":\"Baked British Beans (ToL) - Single - 400g can\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/offer\",\"dfc-b:sku\":\"NCBBT4\",\"dfc-b:stockLimitation\":\"20\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b4\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619\",\"dfc-b:hasQuantity\":\"_:b31\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b32\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627244851\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525627277619/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b25\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Whole-Fava-Beans-Organic-Canned_fcb64fd7-8ca3-465a-8f56-443cf28e0b71.jpg?v=1677760977\",\"dfc-b:name\":\"Organic Whole Fava Beans in Water (ToL) - Case - 12 x 400g cans\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/offer\",\"dfc-b:sku\":\"OCFBCD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b26\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b11\",\"dfc-b:image\":\"https://cdn.shopify.com/s/files/1/0731/8483/7939/products/Whole-Fava-Beans-Organic-Canned_fcb64fd7-8ca3-465a-8f56-443cf28e0b71.jpg?v=1677760977\",\"dfc-b:name\":\"Organic Whole Fava Beans in Water (ToL) - Single - 400g can\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/offer\",\"dfc-b:sku\":\"OCFBT4\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b12\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715\",\"dfc-b:hasQuantity\":\"_:b39\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b40\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628784947\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525628817715/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b7\",\"dfc-b:name\":\"Carlin Peas in Water, Organic (DISTRIBUTOR) - Retail can (400g can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/offer\",\"dfc-b:sku\":\"OCCPT4\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b8\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075\",\"dfc-b:hasQuantity\":\"_:b35\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b36\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654049075/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b21\",\"dfc-b:name\":\"Carlin Peas in Water, Organic (DISTRIBUTOR) - Standard case (12 x 400g can)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/offer\",\"dfc-b:sku\":\"OCCPCD\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525654081843/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b22\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b13\",\"dfc-b:name\":\"Roasted Fava Beans, Lightly Sea Salted (DISTRIBUTOR) - Retail pack (300g)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/offer\",\"dfc-b:sku\":\"NRFSR3\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b14\"}},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedConsumptionFlow\",\"@type\":\"dfc-b:AsPlannedConsumptionFlow\",\"dfc-b:consumes\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563\",\"dfc-b:hasQuantity\":\"_:b41\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedProductionFlow\",\"@type\":\"dfc-b:AsPlannedProductionFlow\",\"dfc-b:hasQuantity\":\"_:b42\",\"dfc-b:produces\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/transformation\",\"@type\":\"dfc-b:AsPlannedTransformation\",\"dfc-b:hasIncome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedConsumptionFlow\",\"dfc-b:hasOutcome\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663584563/plannedProductionFlow\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331\",\"@type\":\"dfc-b:SuppliedProduct\",\"dfc-b:hasQuantity\":\"_:b27\",\"dfc-b:name\":\"Roasted Fava Beans, Lightly Sea Salted (DISTRIBUTOR) - Standard case (10 x 300g)\",\"dfc-b:referencedBy\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/catalogItem\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/catalogItem\",\"@type\":\"dfc-b:CatalogItem\",\"dfc-b:offeredThrough\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/offer\",\"dfc-b:sku\":\"NRFSCX\",\"dfc-b:stockLimitation\":\"-1\"},{\"@id\":\"https://food-data-collaboration-produc-fe870152f634.herokuapp.com/product/44525663617331/offer\",\"@type\":\"dfc-b:Offer\",\"dfc-b:hasPrice\":{\"@id\":\"_:b28\"}}]}","lastId":"8147292258611","remainingProductsCountAfter":0,"success":true,"message":"Products retrieved successfully"} + recorded_at: Fri, 24 May 2024 06:13:50 GMT +recorded_with: VCR 6.2.0 diff --git a/spec/system/admin/dfc_product_import_spec.rb b/spec/system/admin/dfc_product_import_spec.rb index 224b4d89af..f02f4b5565 100644 --- a/spec/system/admin/dfc_product_import_spec.rb +++ b/spec/system/admin/dfc_product_import_spec.rb @@ -41,4 +41,27 @@ RSpec.describe "DFC Product Import" do expect(page).to have_content "Importing a DFC product catalog" expect(page).to have_content "Imported products: 1" end + + it "imports from a FDC catalog", vcr: true do + user.oidc_account.update!( + uid: "testdfc@protonmail.com", + refresh_token: ENV.fetch("OPENID_REFRESH_TOKEN"), + updated_at: 1.day.ago, + ) + + visit admin_product_import_path + + select enterprise.name, from: "Enterprise" + + url = "https://food-data-collaboration-produc-fe870152f634.herokuapp.com/fdc/products?shop=test-hodmedod.myshopify.com" + fill_in "catalog_url", with: url + + expect { + click_button "Import" + }.to change { + enterprise.supplied_products.count + } + + expect(page).to have_content "Importing a DFC product catalog" + end end