@lblod/ember-rdfa-editor-lblod-plugins 0.3.1 → 0.4.0

package/addon/services/standard-template-plugin.js

@@ -0,0 +1,45 @@
+import Service, { inject as service } from '@ember/service';
+import { task, waitForProperty } from 'ember-concurrency';
+import { tracked } from '@glimmer/tracking';
+
+export default class RdfaEditorStandardTemplatePluginService extends Service {
+  @service store;
+  @tracked templates;
+
+  constructor() {
+    super(...arguments);
+    this.loadTemplates();
+  }
+
+  @task
+  *fetchTemplates() {
+    yield waitForProperty(this, 'templates');
+    return this.templates;
+  }
+
+  async loadTemplates() {
+    this.templates = await this.store.query('template', {
+      fields: { templates: 'title,contexts,matches,disabled-in-contexts' },
+    });
+  }
+
+  /**
+     Filter the valid templates for a context.
+     @method templatesForContext
+     @param {Array} Array of templates
+     @param {Array} The path of rdfaContext objects from the root till the current context
+     @return {Array} Array of templates (filtered)
+     @private
+  */
+  templatesForContext(templates, rdfaTypes) {
+    let isMatchingForContext = (template) => {
+      return (
+        rdfaTypes.filter((e) => template.get('contexts').includes(e)).length >
+          0 &&
+        rdfaTypes.filter((e) => template.get('disabledInContexts').includes(e))
+          .length === 0
+      );
+    };
+    return templates.filter(isMatchingForContext);
+  }
+}

package/addon/utils/fetchBesluitTypes.js

@@ -0,0 +1,90 @@
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+
+export default async function fetchBesluitTypes(classificationUri, ENV) {
+  const query = `
+    PREFIX                    conceptscheme: <https://data.vlaanderen.be/id/conceptscheme/>
+    PREFIX                      BesluitType: <https://data.vlaanderen.be/id/concept/BesluitType/>
+    PREFIX              BesluitDocumentType: <https://data.vlaanderen.be/id/concept/BesluitDocumentType/>
+    PREFIX                             skos: <http://www.w3.org/2004/02/skos/core#>
+    PREFIX                              xsd: <http://www.w3.org/2001/XMLSchema#>
+    PREFIX                              rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+    PREFIX                             core: <http://mu.semte.ch/vocabularies/core/>
+    PREFIX                          besluit: <http://lblod.data.gift/vocabularies/besluit/>
+    PREFIX BestuurseenheidClassificatieCode: <http://data.vlaanderen.be/id/concept/BestuurseenheidClassificatieCode/>
+    PREFIX                              sch: <http://schema.org/>
+    PREFIX                             rule: <http://lblod.data.gift/vocabularies/notification/>
+    PREFIX                        lblodRule: <http://data.lblod.info/id/notification-rule/>
+
+    SELECT ?s ?p ?o WHERE {
+      ?s skos:inScheme conceptscheme:BesluitType ;
+         besluit:notificationRule ?rule .
+      ?rule besluit:decidableBy <${classificationUri}> .
+      OPTIONAL { ?rule sch:validFrom ?validFrom . }
+      OPTIONAL { ?rule sch:validThrough ?validThrough . }
+      BIND(now() AS ?currentTime) .
+      BIND(STRLEN(STR(?validFrom)) > 0 AS ?validFromExists) .
+      BIND(STRLEN(STR(?validThrough)) > 0 AS ?validThroughExists) .
+      FILTER(
+        ((?validFromExists && ?validThroughExists) && (?currentTime < ?validThrough && ?currentTime >= ?validFrom)) ||
+        ((!?validFromExists && ?validThroughExists) && (?currentTime < ?validThrough)) ||
+        ((?validFromExists && !?validThroughExists) && (?currentTime >= ?validFrom))
+      ) .
+      ?s ?p ?o .
+      VALUES ?p {
+        skos:prefLabel
+        skos:definition
+        skos:broader
+      }
+    }
+  `;
+  const typeFetcher = new SparqlEndpointFetcher({
+    method: 'POST',
+  });
+  const endpoint = ENV.besluitTypePlugin.endpoint;
+  const bindingStream = await typeFetcher.fetchBindings(endpoint, query);
+  const validBesluitTriples = [];
+  bindingStream.on('data', (triple) => {
+    validBesluitTriples.push(triple);
+  });
+  return new Promise((resolve, reject) => {
+    bindingStream.on('error', reject);
+    bindingStream.on('end', () => {
+      resolve(validBesluitTriples);
+    });
+  }).then(quadsToBesluitTypeObjects);
+}
+
+function quadsToBesluitTypeObjects(triples) {
+  const besluitTypes = new Map();
+  triples.forEach((triple) => {
+    const existing = besluitTypes.get(triple.s.value) || {
+      uri: triple.s.value,
+    };
+    switch (triple.p.value) {
+      case 'http://www.w3.org/2004/02/skos/core#definition':
+        existing.definition = triple.o.value;
+        break;
+      case 'http://www.w3.org/2004/02/skos/core#prefLabel':
+        existing.label = triple.o.value;
+        break;
+      case 'http://www.w3.org/2004/02/skos/core#broader':
+        existing.broader = triple.o.value;
+        break;
+    }
+    besluitTypes.set(triple.s.value, existing);
+  });
+  return createBesluitTypeObjectsHierarchy([...besluitTypes.values()]);
+}
+
+function createBesluitTypeObjectsHierarchy(allBesluitTypes) {
+  const besluitTypes = allBesluitTypes.filter((bst) => !bst.broader);
+  const subTypes = allBesluitTypes.filter((bst) => !!bst.broader);
+  subTypes.forEach((subtype) => {
+    //Use allBesluitTypes to find the parent. This means no tree recursive search process, but we can still create trees of multiple levels deep.
+    const parent = allBesluitTypes.find((type) => type.uri === subtype.broader);
+    if (parent)
+      if (parent.subTypes) parent.subTypes.push(subtype);
+      else parent.subTypes = [subtype];
+  });
+  return besluitTypes;
+}

package/addon/utils/generate-template-plugin/default-resources.js

@@ -0,0 +1,9 @@
+const defaultResources = [
+  'https://say.data.gift/ns/Article',
+  'https://say.data.gift/ns/Subsection',
+  'https://say.data.gift/ns/Section',
+  'https://say.data.gift/ns/Chapter',
+  'https://say.data.gift/ns/Title',
+];
+
+export default defaultResources;

package/addon/utils/instantiate-uuids.js

@@ -0,0 +1,34 @@
+import memoize from './memoize';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Given a template string, we instantiate uuids by matching
+ * ${generateUuid()} pattern in the string and evaluating generateUuid()
+ *
+ * Note: the general approach is similar to converting a string to a template literal, but since
+ * this approach does not work in IE, we had to fall back to plain regex matching.
+ *
+ * @method instantiateUuids
+ * @param {String} templateString
+ *
+ * @return {String} template string with instantiated uuids
+ *
+ * @private
+ */
+
+function determineFunction(string) {
+  switch (string) {
+    case 'generateUuid()':
+      return uuidv4;
+    case 'generateBoundUuid()':
+      return memoize(uuidv4);
+    default:
+      throw new Error(`Could not convert ${string} to function`);
+  }
+}
+export default function instantiateUuids(templateString) {
+  return templateString.replace(/\$\{.+?}/g, (match) => {
+    //input '${content}' and eval('content')
+    return determineFunction(match.substring(2, match.length - 1))();
+  });
+}

package/addon/utils/legislation-types.js

@@ -0,0 +1,32 @@
+const LEGISLATION_TYPES = {
+  decreet: 'https://data.vlaanderen.be/id/concept/AardWetgeving/Decreet',
+  'koninklijk besluit':
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/KoninklijkBesluit',
+  wet: 'https://data.vlaanderen.be/id/concept/AardWetgeving/Wet',
+  'ministerieel besluit':
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/MinisterieelBesluit',
+  'besluit van de vlaamse regering':
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/BesluitVanDeVlaamseRegering',
+  omzendbrief:
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/Omzendbrief',
+  verdrag: 'https://data.vlaanderen.be/id/concept/AardWetgeving/Verdrag',
+  grondwet: 'https://data.vlaanderen.be/id/concept/AardWetgeving/Grondwet',
+  grondwetswijziging:
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/Grondwetwijziging',
+  samenwerkingsakkoord:
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/Samenwerkingsakkoord',
+  wetboek: 'https://data.vlaanderen.be/id/concept/AardWetgeving/Wetboek',
+  'gecoördineerde wetten':
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/GecoordineerdeWetten',
+  'bijzondere wet':
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/BijzondereWet',
+  'genummerd koninklijk besluit':
+    'https://data.vlaanderen.be/id/concept/AardWetgeving/GenummerdKoninklijkBesluit',
+  protocol: 'https://data.vlaanderen.be/id/concept/AardWetgeving/Protocol',
+};
+
+const LEGISLATION_TYPE_CONCEPTS = Object.keys(LEGISLATION_TYPES).map((key) => {
+  return { label: key, value: LEGISLATION_TYPES[key] };
+});
+
+export { LEGISLATION_TYPES, LEGISLATION_TYPE_CONCEPTS };

package/addon/utils/memoize.js

@@ -0,0 +1,8 @@
+export default function memoize(func) {
+  let cache = {};
+  return function () {
+    let args = JSON.stringify(arguments);
+    cache[args] = cache[args] || func.apply(this, arguments);
+    return cache[args];
+  };
+}

package/addon/utils/processMatch.js

@@ -0,0 +1,80 @@
+import { LEGISLATION_TYPES } from './legislation-types';
+import { isBlank } from '@ember/utils';
+
+const STOP_WORDS = ['het', 'de', 'van', 'tot', 'dat'];
+const DATE_REGEX = new RegExp('(\\d{1,2})\\s(\\w+)\\s(\\d{2,4})', 'g');
+const INVISIBLE_SPACE = '\u200B';
+const SPACES_REGEX = new RegExp('[\\s${UNBREAKABLE_SPACE}]+');
+
+export default function processMatch(match) {
+  const matchgroups = match.groups;
+  const type = matchgroups[2];
+  const searchTerms = matchgroups[3];
+  let cleanedSearchTerms = cleanupText(searchTerms)
+    .split(SPACES_REGEX)
+    .filter(
+      (word) => !isBlank(word) && word.length > 3 && !STOP_WORDS.includes(word)
+    )
+    .join(' ');
+
+  let typeLabel;
+  if (/\w+decreet/i.test(type)) {
+    typeLabel = 'decreet';
+    cleanedSearchTerms = `${type} ${cleanedSearchTerms}`;
+  } else if (/decreet/i.test(type)) {
+    typeLabel = 'decreet';
+  } else if (/\w+wetboek/i.test(type)) {
+    typeLabel = 'wetboek';
+    cleanedSearchTerms = `${type} ${cleanedSearchTerms}`;
+  } else if (/wetboek/i.test(type)) {
+    typeLabel = 'wetboek';
+  } else if (/geco[oö]rdineerde[^\S\n]wetten/i.test(type)) {
+    typeLabel = 'gecoördineerde wetten';
+  } else if (/grondwetswijziging/i.test(type)) {
+    typeLabel = 'grondwetswijziging';
+  } else if (/grondwet/i.test(type)) {
+    typeLabel = 'grondwet';
+  } else if (/\w+wet/i.test(type)) {
+    typeLabel = 'wet';
+    cleanedSearchTerms = `${type} ${cleanedSearchTerms}`;
+  } else if (/wet/i.test(type)) {
+    typeLabel = 'wet';
+  } else {
+    typeLabel = type.toLowerCase().trim();
+  }
+
+  const typeUri = LEGISLATION_TYPES[typeLabel] || LEGISLATION_TYPES['decreet'];
+  return {
+    text: cleanedSearchTerms,
+    legislationTypeUri: typeUri,
+    range: match.groupRanges[1],
+  };
+}
+
+function cleanupText(text) {
+  if (!text) return '';
+  const { textWithoutDates } = extractDates(text);
+  const textWithoutOddChars = textWithoutDates.replace(
+    new RegExp(`[,.:"()&${INVISIBLE_SPACE}]`, 'g'),
+    ''
+  );
+  const articleIndex = textWithoutOddChars.indexOf('artikel');
+  return articleIndex >= 0
+    ? textWithoutOddChars.slice(0, articleIndex)
+    : textWithoutOddChars;
+}
+
+function extractDates(text) {
+  let date;
+  const matches = [];
+  while ((date = DATE_REGEX.exec(text)) !== null) {
+    matches.push(date);
+  }
+
+  let textWithoutDates = text;
+  for (let match of matches) {
+    textWithoutDates = textWithoutDates.replace(match[0], '');
+  }
+
+  return { dates: matches, textWithoutDates };
+}

package/addon/utils/roadsign-regulation-plugin/fetchData.js

@@ -0,0 +1,78 @@
+import { POTENTIALLY_ZONAL_URI } from '../../constants';
+
+function buildFilters({ zonality, type, codes, category }) {
+  const filters = [];
+  if (zonality) {
+    filters.push(
+      `FILTER(?zonality IN (<${zonality}>, <${POTENTIALLY_ZONAL_URI}>))`
+    );
+  }
+  if (type) {
+    filters.push(`FILTER(?signType = <${type}>)`);
+  }
+  if (codes) {
+    filters.push(`
+        ${codes
+          .map(
+            (uri) => `
+              ?uri ext:relation/ext:concept <${uri}>.
+            `
+          )
+          .join(' ')}
+    `);
+  }
+  if (category) {
+    filters.push(`FILTER(?signClassification = <${category}>)`);
+  }
+  return filters;
+}
+
+export function generateMeasuresQuery({
+  zonality,
+  type,
+  codes,
+  category,
+  pageStart = 0,
+  count,
+}) {
+  const filters = buildFilters({ zonality, type, codes, category });
+  let pagination = '';
+  if (!count) {
+    pagination = `LIMIT 10 OFFSET ${pageStart}`;
+  }
+  const query = `
+SELECT ${
+    count
+      ? '(COUNT(DISTINCT(?template)) AS ?count)'
+      : '?uri ?label ?basicTemplate ?annotatedTemplate ?zonality ?temporal'
+  }
+WHERE {
+    ?uri a lblodMobiliteit:TrafficMeasureConcept;
+         skos:prefLabel ?label;
+         ext:zonality ?zonality;
+         ext:relation ?relationUri;
+         ext:template ?template.
+         ?template ext:annotated ?annotatedTemplate;
+                   ext:value ?basicTemplate.
+    ?relationUri a ext:MustUseRelation ;
+                 ext:concept ?signUri.
+    ?signUri a ?signType;
+             skos:prefLabel ?signCode.
+            
+    ${filters.join('\n')}
+  OPTIONAL {
+    ?uri ext:temporal ?temporal.
+  }
+  OPTIONAL {
+    ?signUri org:classification ?signClassification.
+  }
+}
+${
+  count
+    ? ''
+    : `GROUP BY ?uri ?label ?template ?zonality\n ORDER BY ASC(strlen(str(?label))) ASC(?label)`
+}
+${pagination}
+`;
+  return query;
+}

package/addon/utils/roadsign-regulation-plugin/includeInstructions.js

@@ -0,0 +1,10 @@
+export default function includeInstructions(html, instructions, annotated) {
+  let finalHtml = html;
+  for (let instruction of instructions) {
+    finalHtml = finalHtml.replaceAll(
+      `\${${instruction.name}}`,
+      annotated ? instruction.annotatedTemplate : instruction.template
+    );
+  }
+  return finalHtml;
+}

package/addon/utils/variable-plugins/default-variable-types.js

@@ -0,0 +1,56 @@
+import { fetchCodeListsByPublisher } from './fetch-data';
+
+export const defaultVariableTypes = {
+  text: {
+    label: 'text',
+    template: `
+      <span property="dct:type" content="text"></span>
+      <span property="ext:content">
+        <span class="mark-highlight-manual">\${text}</span>
+      </span>
+    `,
+  },
+  number: {
+    label: 'number',
+    template: `
+      <span property="dct:type" content="number"></span>
+      <span property="ext:content" datatype="xsd:integer">
+        <span class="mark-highlight-manual">\${number}</span>
+      </span>
+    `,
+  },
+  date: {
+    label: 'date',
+    template: `
+      <span property="dct:type" content="date"></span>
+      <span property="ext:content" datatype="xsd:date">
+        <span class="mark-highlight-manual">\${date}</span>
+      </span>
+    `,
+  },
+  location: {
+    label: 'location',
+    template: (endpoint) => `
+      <span property="dct:type" content="location"></span>
+      <span property="dct:source" resource="${endpoint}"></span>
+      <span property="ext:content">
+        <span class="mark-highlight-manual">\${location}</span>
+      </span>
+    `,
+  },
+  codelist: {
+    label: 'codelist',
+    fetchSubtypes: async (endpoint, publisher) => {
+      const codelists = fetchCodeListsByPublisher(endpoint, publisher);
+      return codelists;
+    },
+    template: (endpoint, selectedCodelist) => `
+      <span property="ext:codelist" resource="${selectedCodelist.uri}"></span>
+      <span property="dct:type" content="codelist"></span>
+      <span property="dct:source" resource="${endpoint}"></span>
+      <span property="ext:content">
+        <span class="mark-highlight-manual">\${${selectedCodelist.label}}</span>
+      </span>
+    `,
+  },
+};

package/{dist/fetch-data-284bf106.js → addon/utils/variable-plugins/fetch-data.js}

@@ -19,6 +19,7 @@ function generateCodeListOptionsQuery(codelistUri) {
   `;
   return codeListOptionsQuery;
 }
+
 function generateCodeListsByPublisherQuery(publisher) {
   const codeListOptionsQuery = `
     PREFIX lblodMobilitiet: <http://data.lblod.info/vocabularies/mobiliteit/>
@@ -28,36 +29,54 @@ function generateCodeListsByPublisherQuery(publisher) {
     SELECT DISTINCT * WHERE { 
       ?uri a lblodMobilitiet:Codelist;
         skos:prefLabel ?label.
-      ${publisher ? `
+      ${
+        publisher
+          ? `
         ?uri dct:publisher <${publisher}>.
-      ` : ''}
+      `
+          : ''
+      }
     }
   `;
   return codeListOptionsQuery;
 }
-async function fetchCodeListOptions(endpoint, codelistUri) {
-  const codelistsOptionsQueryResult = await executeQuery(endpoint, generateCodeListOptionsQuery(codelistUri));
+
+export async function fetchCodeListOptions(endpoint, codelistUri) {
+  const codelistsOptionsQueryResult = await executeQuery(
+    endpoint,
+    generateCodeListOptionsQuery(codelistUri)
+  );
   const options = parseCodelistOptions(codelistsOptionsQueryResult);
   return {
-    type: codelistsOptionsQueryResult.results.bindings[0] && codelistsOptionsQueryResult.results.bindings[0].type ? codelistsOptionsQueryResult.results.bindings[0].type.value : '',
-    options
+    type:
+      codelistsOptionsQueryResult.results.bindings[0] &&
+      codelistsOptionsQueryResult.results.bindings[0].type
+        ? codelistsOptionsQueryResult.results.bindings[0].type.value
+        : '',
+    options,
   };
 }
-async function fetchCodeListsByPublisher(endpoint, publisher) {
-  const codelistsOptionsQueryResult = await executeQuery(endpoint, generateCodeListsByPublisherQuery(publisher));
+
+export async function fetchCodeListsByPublisher(endpoint, publisher) {
+  const codelistsOptionsQueryResult = await executeQuery(
+    endpoint,
+    generateCodeListsByPublisherQuery(publisher)
+  );
   const bindings = codelistsOptionsQueryResult.results.bindings;
-  return bindings.map(binding => ({
+  return bindings.map((binding) => ({
     uri: binding.uri.value,
-    label: binding.label.value
+    label: binding.label.value,
   }));
 }
+
 function parseCodelistOptions(queryResult) {
   const bindings = queryResult.results.bindings;
-  return bindings.map(binding => ({
+  return bindings.map((binding) => ({
     value: binding.label.value,
-    label: binding.label.value
+    label: binding.label.value,
   }));
 }
+
 async function executeQuery(endpoint, query) {
   const encodedQuery = encodeURIComponent(query.trim());
   const response = await fetch(endpoint, {
@@ -65,16 +84,15 @@ async function executeQuery(endpoint, query) {
     mode: 'cors',
     headers: {
       Accept: 'application/sparql-results+json',
-      'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
+      'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
     },
-    body: `query=${encodedQuery}`
+    body: `query=${encodedQuery}`,
   });
   if (response.ok) {
     return response.json();
   } else {
-    throw new Error(`Request to MOW backend was unsuccessful: [${response.status}] ${response.statusText}`);
+    throw new Error(
+      `Request to MOW backend was unsuccessful: [${response.status}] ${response.statusText}`
+    );
   }
 }
-
-export { fetchCodeListOptions as a, fetchCodeListsByPublisher as f };
-//# sourceMappingURL=fetch-data-284bf106.js.map