MetadataHandler

Jump to bottomEditNew page
larsb edited this page Jan 26, 2015 · 15 revisions

The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.
Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.
An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).

What's in the metadata?

The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:

  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)

Technical representation

In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.
An example can be found [here](example metadata).

Creating a MetadataHandler

Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:

var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void Sets a new, complete set of metadata in the MetadataHandler.

`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler
#### getMetadata(): object Returns the complete JSON metadata object.
#### getActor(): object Returns the 'actor' sub-section of the metadata.
#### getGenerator(): object Returns the 'generator' sub-section of the metadata.
#### getProvider(): object Returns the 'provider' sub-section of the metadata.
#### getTarget(): object Returns the 'provider' sub-section of the metadata.
#### setTarget(newTarget: object): void Sets a new 'target' sub-section in the metadata object.

`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler

Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.
#### getTargetDisplayName(): string A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).
#### setTargetDisplayName(newName: string): void A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).

`newName: string` The new target's displayName to be set in the MetadataHandler
Add a custom footer
Add a custom sidebar

Clone this wiki locally

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
MetadataHandler
Jump to bottomEditNew page

larsb edited this page Jan 26, 2015
·
15 revisions
The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.

Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.

An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).
What's in the metadata?
The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:
  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)
Technical representation
In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.

An example can be found [here](example metadata).
Creating a MetadataHandler
Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:
var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void
Sets a new, complete set of metadata in the MetadataHandler.


`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler


#### getMetadata(): object
Returns the complete JSON metadata object.


#### getActor(): object
Returns the 'actor' sub-section of the metadata.


#### getGenerator(): object
Returns the 'generator' sub-section of the metadata.


#### getProvider(): object
Returns the 'provider' sub-section of the metadata.


#### getTarget(): object
Returns the 'provider' sub-section of the metadata.


#### setTarget(newTarget: object): void
Sets a new 'target' sub-section in the metadata object.


`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler


Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.


#### getTargetDisplayName(): string
A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).


#### setTargetDisplayName(newName: string): void
A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).


`newName: string` The new target's displayName to be set in the MetadataHandler

 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
MetadataHandler
Jump to bottomEditNew page

larsb edited this page Jan 26, 2015
·
15 revisions
The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.

Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.

An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).
What's in the metadata?
The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:
  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)
Technical representation
In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.

An example can be found [here](example metadata).
Creating a MetadataHandler
Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:
var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void
Sets a new, complete set of metadata in the MetadataHandler.


`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler


#### getMetadata(): object
Returns the complete JSON metadata object.


#### getActor(): object
Returns the 'actor' sub-section of the metadata.


#### getGenerator(): object
Returns the 'generator' sub-section of the metadata.


#### getProvider(): object
Returns the 'provider' sub-section of the metadata.


#### getTarget(): object
Returns the 'provider' sub-section of the metadata.


#### setTarget(newTarget: object): void
Sets a new 'target' sub-section in the metadata object.


`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler


Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.


#### getTargetDisplayName(): string
A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).


#### setTargetDisplayName(newName: string): void
A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).


`newName: string` The new target's displayName to be set in the MetadataHandler

 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
MetadataHandler
Jump to bottomEditNew page

larsb edited this page Jan 26, 2015
·
15 revisions
The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.

Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.

An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).
What's in the metadata?
The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:
  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)
Technical representation
In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.

An example can be found [here](example metadata).
Creating a MetadataHandler
Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:
var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void
Sets a new, complete set of metadata in the MetadataHandler.


`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler


#### getMetadata(): object
Returns the complete JSON metadata object.


#### getActor(): object
Returns the 'actor' sub-section of the metadata.


#### getGenerator(): object
Returns the 'generator' sub-section of the metadata.


#### getProvider(): object
Returns the 'provider' sub-section of the metadata.


#### getTarget(): object
Returns the 'provider' sub-section of the metadata.


#### setTarget(newTarget: object): void
Sets a new 'target' sub-section in the metadata object.


`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler


Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.


#### getTargetDisplayName(): string
A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).


#### setTargetDisplayName(newName: string): void
A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).


`newName: string` The new target's displayName to be set in the MetadataHandler

 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
MetadataHandler
Jump to bottomEditNew page

larsb edited this page Jan 26, 2015
·
15 revisions
The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.

Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.

An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).
What's in the metadata?
The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:
  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)
Technical representation
In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.

An example can be found [here](example metadata).
Creating a MetadataHandler
Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:
var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void
Sets a new, complete set of metadata in the MetadataHandler.


`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler


#### getMetadata(): object
Returns the complete JSON metadata object.


#### getActor(): object
Returns the 'actor' sub-section of the metadata.


#### getGenerator(): object
Returns the 'generator' sub-section of the metadata.


#### getProvider(): object
Returns the 'provider' sub-section of the metadata.


#### getTarget(): object
Returns the 'provider' sub-section of the metadata.


#### setTarget(newTarget: object): void
Sets a new 'target' sub-section in the metadata object.


`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler


Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.


#### getTargetDisplayName(): string
A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).


#### setTargetDisplayName(newName: string): void
A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).


`newName: string` The new target's displayName to be set in the MetadataHandler

 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
MetadataHandler
Jump to bottomEditNew page

larsb edited this page Jan 26, 2015
·
15 revisions
The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.

Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.

An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).
What's in the metadata?
The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:
  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)
Technical representation
In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.

An example can be found [here](example metadata).
Creating a MetadataHandler
Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:
var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void
Sets a new, complete set of metadata in the MetadataHandler.


`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler


#### getMetadata(): object
Returns the complete JSON metadata object.


#### getActor(): object
Returns the 'actor' sub-section of the metadata.


#### getGenerator(): object
Returns the 'generator' sub-section of the metadata.


#### getProvider(): object
Returns the 'provider' sub-section of the metadata.


#### getTarget(): object
Returns the 'provider' sub-section of the metadata.


#### setTarget(newTarget: object): void
Sets a new 'target' sub-section in the metadata object.


`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler


Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.


#### getTargetDisplayName(): string
A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).


#### setTargetDisplayName(newName: string): void
A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).


`newName: string` The new target's displayName to be set in the MetadataHandler

 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
MetadataHandler
Jump to bottomEditNew page

larsb edited this page Jan 26, 2015
·
15 revisions
The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.

Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.

An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).
What's in the metadata?
The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:
  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)
Technical representation
In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.

An example can be found [here](example metadata).
Creating a MetadataHandler
Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:
var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void
Sets a new, complete set of metadata in the MetadataHandler.


`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler


#### getMetadata(): object
Returns the complete JSON metadata object.


#### getActor(): object
Returns the 'actor' sub-section of the metadata.


#### getGenerator(): object
Returns the 'generator' sub-section of the metadata.


#### getProvider(): object
Returns the 'provider' sub-section of the metadata.


#### getTarget(): object
Returns the 'provider' sub-section of the metadata.


#### setTarget(newTarget: object): void
Sets a new 'target' sub-section in the metadata object.


`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler


Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.


#### getTargetDisplayName(): string
A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).


#### setTargetDisplayName(newName: string): void
A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).


`newName: string` The new target's displayName to be set in the MetadataHandler

 Add a custom footer

 Add a custom sidebar

Clone this wiki locally

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
MetadataHandler
Jump to bottomEditNew page

larsb edited this page Jan 26, 2015
·
15 revisions
The MetadataHandler encapsulates and provides access to a set of metadata items needed by client-side apps in Go-Lab. In particular, these metadata items are also required by the ActionLogger (to add it to the action log) and by the StorageHandler (to add it to stored artefacts). Typical metadata items would be the name and identifier or the current user, name and identifier of the current working document, the current ILS etc.

Every instance of an app creates its own MetadataHandler, and passes it on to the ActionLogger and StorageHandler.

An app is responsible to update the information in the MetadataHandler in case of changes. At the moment of writing this, this is only necessary when an artefact is stored and given a new name (cf. setTargetDisplayName()).
What's in the metadata?
The metadata is based on the Activity Streams specification, since this is used for action logging as well and thus brings consistency by design. The metadata consists of the following sections:
  • actor: holds information about the current user
  • target: holds information about the current working document
  • generator: holds information about the current app
  • provider: holds information about the current context (i.e., the ILS)
Technical representation
In the current implementation, the metadata is represented as a JSON object. Using JSON integrates well with other technologies for the development of web-based applications, in particular with JavaScript. In addition, JSON can be serialised and parsed easily, while it still remains human-readable. The following MetadataHandler API returns and accepts the metadata items or metadata sections in JSON.

An example can be found [here](example metadata).
Creating a MetadataHandler
Currently, the MetadataHandler is created with a given set of metadata items. In future implementations, an increasing number of items will be automatically set through the ILS Metawidget API. For this reason, the construction of the MetadataHandler is handled asynchronously, requiring a callback function at construction time. The following code fragment illustrates this approach:
var hypothesisToolMetadataHandler;
new golab.ils.metadata.GoLabMetadataHandler({
"actor": {
"objectType": "person",
"id": "e1b8948f-321e-78ca-d883-80500aae71b5",
"displayName": "anonymized"
},
"target": {
"objectType": "hypotheses",
"id": "4b8f69e3-2914-3a1a-454e-f4c157734bd1",
"displayName": "unnamed hypotheses"
},
"generator": {
"objectType": "application",
"url": "http://www.golabz.eu/app/hypothesis-tool",
"id": "c9933ad6-dd4a-6f71-ce84-fb1676ea3aac",
"displayName": "hypothesisScratchpad"
},
"provider": {
"objectType": "ils",
"url": "http://graasp.epfl.ch/metawidget/1/b387b6f",
"id": "10548c30-72bd-0bb3-33d1-9c748266de45",
"displayName": "unnamed ILS"
}}, function(error, metadataHandler) {
if (error != undefined) {
console.error ("Something went wrong when creating the MetadataHandler: "+error);
} else {
hypothesisToolMetadataHandler = metadataHandler
}
})

API

#### setMetadata(newMetadata: object): void
Sets a new, complete set of metadata in the MetadataHandler.


`newMetadata: object` The new metadata JSON object to be set in the MetadataHandler


#### getMetadata(): object
Returns the complete JSON metadata object.


#### getActor(): object
Returns the 'actor' sub-section of the metadata.


#### getGenerator(): object
Returns the 'generator' sub-section of the metadata.


#### getProvider(): object
Returns the 'provider' sub-section of the metadata.


#### getTarget(): object
Returns the 'provider' sub-section of the metadata.


#### setTarget(newTarget: object): void
Sets a new 'target' sub-section in the metadata object.


`newTarget: object` The new 'target' sub-section JSON object to be set in the MetadataHandler


Note: Typically, only the 'target' metadata (describing the current working document) changes during a tool's lifecycle. If other metadata sections change dynamically in future, more functions like this will be added.


#### getTargetDisplayName(): string
A convenience function that directly returns the displayName of the 'target' sub-section (i.e. the current document name).


#### setTargetDisplayName(newName: string): void
A convenience function to directly set a new displayName of the 'target' sub-section (i.e. setting a new document name).


`newName: string` The new target's displayName to be set in the MetadataHandler

 Add a custom footer

 Add a custom sidebar

Clone this wiki locally