Based off a discussion on Apereo Slack https://apereo.slack.com/archives/C02B68G62/p1549058151102500

There is interest in putting together an option and/or template for multi-language support within a web component.

Just to kick off ideas on how a course glossary might work. I saw the way that Wikipedia links to other articles in its mobile app and thought it worked really well:

Also potentially links with elmsln/elmsln#620

Create an area that's keeping track of last used

A block that can present the items in list form and grouped. This site on the right has the http://freebookapalooza.blogspot.com/search/label/Region%3A%20British%2FCeltic categories block. This block would be a query w/ a generated field (something we currently don't support...)

<site-query result="{{__items}}" unique="true" entity="metadata.fields.tags">
<iron-list items="[[__items]]" as="item">
  <template>
    <span>[[item.value]] ([[item.count]])</span>
  </template>
</iron-list>

Find all the tags, focusing on tags as the central item returned (almost like making the thing in entity what is centric, default being a $node or something), only return unique ones. This would then return 'value' which would have what was found (so metadata.fields.images could be centric as well if desired or metadata.files) as well as a count if (if more then 1 value found just do it that way).

Feature idea:
I've been asked a few times about being able to provide version history to learners for both the book as a whole and the page. I know Drupal has the revision history functionality which is similar but saw this openstax textbook and quite liked the way they'd implemented a solution as a kind of footnote to the page here:

https://cnx.org/contents/[email protected]:gNLp76vu@13/Themes-and-Concepts-of-Biology

I feel like this might've been brought up previously, so apologies if I'm retracing old ground.

I'm looking to build something like an online workbook that includes checkboxes, text boxes etc, where each student can select a check box, or type and their answers will be saved for the next time they revisit the page. Each student would only ever see their selections/answers though

I think I can do a lot of what I need with just using the webform module and adding webforms throughout, but it's not the best solution usuability wise. So I was just putting the idea out there to see if there's another way of going about this? Or if there's any plans for this sort of thing?

This way people could write and validate HAX wiring in the browser... like on the haxtheweb.org website itself....
Then we could supply instructions on what to do with said wiring for those not using the WCFactory tooling but wanting to automate their wiring up designs.

What I would suggest is that any relative links to configuration files, or "global files" would be better managed by an npm package. The benefits of this would be that the configs would be versioned so potentially your element would be pegged to a specific config version. It would also mean that you could change the location or move it out of this repo and into another and it would break the build.

Being that we are going all-in on Lerna, I would feel comfortable with making a lot of npm packages.

click import
paste a git repo
hit import

script should pull that in locally in the _sites directory and then add it as a valid site if it has a sites.json file it understands (if not it should get rid of the repo and say it couldnt do it)

targets for common import

To start out, let's hit things that are similar to us

• gitbook
• md file import
• git repo (that's in an above format or haxcms itself just to import sites)
• internal large proprietary cms X (aka other things, should be flexible to support new stuff
• docx file import

two slots. one with the content as a tease. one that is opened in a modal. optional icon.
Use case
"Watch a video installing HAXcms with MAMP"
icon: video
Reveal: "<video-player....."

Same true for education content / related material / "Need a refresher?" with an icon of a book and click to open that shows a PDF or something

wire it to HAX... obviously

So right now we talk in elements but elements need to be assembled into an application (even for Drupal and other CMSs you need a "static" mock up first).

To do this now let's just do it in elements but in the future it would be good to have an actually create new app command that structured things a bit differently.

Content Authoring Mode (not all UI elements would appear at once)

Example menus for editing mode switching: (page/content, layout, nodes)

Layout (or template region editing) Mode

Left panel dropdown (not all options listed)

Nodes editing mode

HAXeditor's text context menu has support for a "advanced item"

When you click this and have highlighted text, a modal pops up that has 3 items in it currently.

These items are actually driven dynamically via HAXschema being parsed and only "inline" items being returned:

Here's the code from hax-text-context (my version of rich-text-editor more or less) which is able to surface these definitions and presents them in a modal:

let values = {
            text: window.HaxStore.instance.activePlaceHolder.toString()
          };
          let type = "inline";
          let haxElements = window.HaxStore.guessGizmo(type, values);
          // see if we got anything
          if (haxElements.length > 0) {
            // hand off to hax-app-picker to deal with the rest of this
            window.HaxStore.instance.haxAppPicker.presentOptions(
              haxElements,
              type,
              "Transform selected text to..",
              "gizmo"
            );
          }

window.HaxStore.guessGizmo('inline', values); is the key piece here for what your doing. This will give you the HAX elements that can be used inline soo... I imagine you'll be able to run with this and leverage the schema itself in order to add additional buttons to rich text on the fly as a demo so we can then work towards merging rich text into hax and replacing my text bar / operations entirely :)

default mobile behavior hides the transcript

Document that this file converts the path resolutions to be IAM based

I have a bunch of Media assets all linked to one course. Then I've got a separate course created at a later point that also references all the same media assets.

Is there a way to filter media assets by course, select all, then set them to also be associated with the new course?

Need to come up with the best way to do something like this --- https://disqus.com/admin/install/platforms/universalcode/

Theme shouldn't require it... though themes saying "I support diqus" is a bit odd. Seems more of a "use this element if you want to include it" and then the element would require binding to some kind of internal (to the theme) field.

This is a good use-case to be a vehicle for integrating this and other micro-services in the future.

https://lit-element.polymer-project.org/try style but also mix in @heyMP 's iframe-loader element

Additional details on how we can map to their API -- https://stackblitz.com/docs

This would be great for having an element that allowed for running demo's off of github / automatically setting them up as if you look at their URL naming structure. It also has support in their SDK for invoking projects on demand via post values among other things.

This could be a really impressive way to present code examples in context with hax as the editor to setup the demo space.

action buttons operations

• create with preset themes (a la gDocs)
• import
• clone
• delete
• publish to web
• sync with repo
• listing item
  • select box
  • icon or image
  • title and subtitle
  • filter dates
  • action buttons/operations
  • more button
• filter bar
• top bar nav
  • Left logo
  • HAX CMS custom header name (HAX Publisher in this case)
  • account settings link
  • docs link
  • cms settings link

great idea from @nikkimk to solve some of the print item regression that exists. theme would effectively open the site again in a new tab except w/ a flag that would force the print theme, display the number of items requested (just as the print buttons do) and then trigger a print based on whats visible.

Method in the CIS for deleting a course. This would:

• Delete all instances of the course and the associated service instances from CIS
• Uninstall all services of the course (course outline/studio Drupal sites)
• Delete all linked instances in the other authorities
• Remove any sections associated with the course that are associated with other content types (Media for example)
• Remove any associations of the course from a students record/profile
• remove field collections that are associated elmsln/elmsln#2374
  Goal is just for easier ELMS management of old courses, or courses created in error, as demos, or testing etc.

Ultimately the goal would be to pair this with branching/interactive and re-enable once all branching questions are complete.

See MUSIC 109 Lesson 9 Quiz audio clips.

This is kind of an addition to the work done for elmsln/elmsln#1758 but to support flipping between related courses.

As described in elmsln/elmsln#1963 we're developing a programme which combines a few different courses. In this case I'll just be adding some custom network menu links to those courses but I don't think this is a sustainable approach in line with the design pattern.

Instead, what if students also saw a dropdown menu here (same way that admins/staff) see it:

But instead of admin controls, they have the option of switching to another course that forms part of the same programme (of which there's currently a content type in place).

From Sonya's testing: When I hit the transcript buttons, the buttons seem to bleed into the video below. Not sure what is going on there.

I'm waiting to learn more about this issue, but am leaving this placeholder as a reminder.

Utilizing our own happy ELMS snowflake; if we put the learner (visually) at the center of a network diagram we can start to visualize a learner's progression through a program of student. The world revolves around the learner, and their "level" can be related to years of study in a program. For example, if I'm a year 2, I can see active courses that I'm taking as filtered out visually by that semester / year of study. I'm then able to drill down into that semester and see all my courses (again, as a network). Then if I select one of those the network diagram could unfold to show-case the aspects of that course off to that side.

This could effectively replace all "dashboard" displays that get incredibly bloated over time while reducing the number of clicks to get to anything significantly.

@michael-collins @nikkimk thoughts on this as a program level visualization of the student and their moving through things (could be applied to general education program too tho not our aim initially)

For hybrid courses (partly in-residence/partly online), keeping accurate record of attendance is required by policy. We need to build a tool, perhaps as part of the class roster, that can do this. However, I'd like to be able to view the end of semester as data visualization so I can make correlations to when assignments are due, what the weather was that day, and other events that might be happening to how often students are absent or late. Students should also be able to view their own data.

Issues:

• Auto create images via docker-hub on latest and tagged releases
• Docker won't npm install a package.json with template variables in them. Need to alter package.json without fsCopyTemplate
• ability to issue commands into the container and it be included w/ the monorepo that it spits out so people don't need our tooling in order to work with it accurately

all sites we ever make will have the same underlaying structure that you could query and remix at will.

This is relative to Drupal 9 integration:

• need to do "use hax" configuration per entity type / bundle
• option to show the normal edit form vs hax edit form
• Installing Drupal 8 needs to have the "filter out text" box unchecked
• draft versions of nodes / form fields.. maybe just the HAXcms settings button that then loads HAXSchema from a backend and we teach these other systems how to output HAXSchema (something expressed in the ELMS:LN issue queue as well)
• manage layouts via a Drupal UI
• manage templates via the UI
• make the autoloader checkbox based + adding new ones

Feature request:
The accessible fallback feature is really great. I think this could work really well as a way of loading different media content automatically depending on the context it's being delivered too.

It would work slightly differently in that the media choice would be automatic instead of user-driven.

Mobile fallback and/or tablet fallback could automatically load a different media type based on whether the screen size is small or medium. A use case for this is if something like a H5P presentation is being used and the functionality is compromised when it is scaled down on mobile phones. Maybe you want to load an image instead.

Print fallback would automatically load a different media type if you were printing the course page, or using the Print PDF feature. Zurb has some print visibility classes that I used to use for this purpose (http://foundation.zurb.com/sites/docs/v/5.5.3/components/visibility.html) but it's difficult to maintain and manage via the wysiwyg source code. Use case for this is if you have any type of interactive content (let's say a multiple choice quiz), but you just want some static content loaded instead which loads just the quiz questions. Or you have an embedded video but it makes more sense to display a link to that video instead when printing.

This would inform users about their own usage behavior as well as give us a way of showing them the data that's being kept about them.

Noticed inside test engine:

/Users/travis/.wcfconfig/ is missing! Run wcf start from your desired directory to get started!
(node:3347) TypeError Plugin: @wcfactory/cli: Cannot read property 'companyDir' of undefined

We should audit things for 404 status on the fly when we save and report back to the user

Maybe something like this: https://www.npmjs.com/package/broken-link-checker

Design thinking activities are difficult to do on your own, particularly for new design students. A moderator is commonly used to keep time and motivate for the next steps in a design session. Are we able to facilitate something like this within the studio?

I plan to create design thinking audio tracks. The student will play the audio track, and I'll be giving prompts and instructions over the course of time, perhaps as short as 10 minutes, and as long as 45 min-hour. I might provide two audio tracks, one track that is hands free and runs for 45 minutes or so, and another condensed one that a student can pause, and then play without all of the dead space between prompts (for people with poor internet connections).

It would be amazing if we could have students actively submitting their work as they follow along. For instance, if they run it from their phone, it could prompt them to take a picture of their work, and upload it to the studio. Then it moves to the next step.

Thoughts?

Organizations allow multiple users to manage a group of hax sites. They can share individual c
Sites with people as well as have a series of shared sites together.

These should be kept separate from the user sites stuff so that we can have more flexibility with needs of groups of shared sites.

This way you could update your templates when they change without having to do it manually

elmsln/WCFactory#250

Education suffers from a lag in feedback. Gamers expect real-time feedback, and when they have even a slight lag, it impairs their performance and creates frustration. Timely feedback is even more critical for functioning within a group. Yet the only feedback students provide their peers (if any) is a peer evaluation at the end of their experience. Instead of getting timely feedback to course-correct, team members receive too little too late.

We know that students hate group work, but we also know working in a group is important. Dropping students into groups without teaching how to work together or monitoring their progress is like throwing them in the deep end to learn to swim. Some will learn to swim despite this. Some will learn to fear the water. And some will learn to use their peers as floatation devices.

I think the next-generation peer evaluation tool, should be more than a peer-eval at the end. I think this service should facilitate groups from the moment they are assigned to the post-submission peer evaluation.

I think the tool should periodically check in with team members, lead them to resources for tackling specific issues, and help them draft communications with each other. And as it collects this ongoing data, UI components provide an overview of team health to the students and instructors, as real-time feedback.

Example:
When I am assigned to a group, perhaps they system suggests an introduction activity or has people agree on availability and preferred modes of communication.

Every week (or every few days, or however the instructor configures it), I get likert or slider question about how the experience is going overall, and the option to do a likert on each team member.

If I rate something extremely low, perhaps the system asks further questions about why. Based on my answer I may be directed to a helpful article or asked if I want to send a message to that team member or my instructor. It may even offer suggested wording for how to provide that feedback.

If I rate something extremely high, perhaps the system suggests that I praise someone on my team. It may even offer suggested wording for how to provide that feedback. I may even have the option to provide them a badge or special status.

My instructor can see a dashboard with ratings teams, and be able to drill down into a team to look at individual members. They can also see incoming messages, which are coded by positive or negative feedback. And the can see who has been awarded badges.

When i run yarn start at the factory level. Storybook opens but the components don't render with the correct styles.

storybook

polymer

We need hooks in the publishing routine to allow for things to be published conditionally. For example right now everything is to the published directory (which is fine) but then it's sent to gh-pages by default if that block is in the publishing section.

Instead of just this integration, we should make it support ANY operation that's been defined in that publishing block. This would make it easier to do bulk publishing to gh-pages but also position things so that we can support the OER, courses and "sites" use cases that we're trying to engineer into our patient zero deploy.

@djfusco Either that or clean up the scope so that its this relationship:

• pouch-db fires an event
• data-viz brokers that to be visualized
• data-viz invokes the chartist-render element to visualize this data set

This way we get a nice separation of concerns.

https://packagist.org/packages/ml/json-ld

we could use this to start to build a json ld graph on the fly when pages are saved. This would help w/ the OER Schema use-case we have of wanting to understand the relationships between material without having to write complex schema (on the part of the user).

See example https://courses.worldcampus.psu.edu/public/multimedia/math034/branchingvideo_Buck.html

I was trying to create a new element in my windows machine after pulling down my factory from git. I keep getting this error:
TypeError: Cannot read property 'value' of undefined at Object.when (C:/Users/montesje/AppData/Local/Yarn/Data/global/node_module s/@wcfactory/cli/src/questions/element.js:25:40) at promptUser (C:/Users/montesje/AppData/Local/Yarn/Data/global/node_modules /@wcfactory/cli/src/utils/commands.js:34:40) at Element.run (C:/Users/montesje/AppData/Local/Yarn/Data/global/node_module s/@wcfactory/cli/src/commands/element.js:12:19) at Element._run (C:/Users/montesje/AppData/Local/Yarn/Data/global/node_modul es/@oclif/command/lib/command.js:35:31)

This is probably an idea that would be more useful in the sciences, but could have interesting applications elsewhere too.

Text-to-speech does a very poor job with the pronunciation of complex scientific words. In our case, properly pronouncing drug/medicine names is important for our learners to communicate medications to patients, but it's always difficult to decipher how a word should be pronounced from how it's spelt.

http://howjsay.com/ has an online library of audio clips where the word is read out properly, which is where this idea came from.

Therefore my plan was to record short audio clips reading specific words out, upload them to Media - then have an option within the course (possibly in the accessibility settings) to switch on a 'medicine name audio library' to get the following effect when rolling your mouse over (or clicking) the word in your course:
http://codepen.io/rickhumphries/pen/MKLYXP
(try typing metronidazole into https://www.ivona.com/ and you'll see how different they can be!)

My thinking is that the instructor could create their own libraries of words - and link each word to an audio shortcode from Media. The student would have the option in the accessibility settings to switch on/off a specific library. If a library is switched on, the tool scans the book for all instances of this word and processes it in a way so that of you click the word, the audio file plays.

Just wondering if this is an interesting concept for anyone else - and to get implementation ideas too...

A highly useful element (that I've had on a back burner for quite some time ... and would be happy to help implement and might be useful for K-12) would be audio recordings for the purposes of spelling practice.

Initially:
A word is entered with an audio recording and the user has the opportunity to try spelling it from the pronunciation/audio-recording (then the system compares the actual spelling with the user's spelling). (This could piggy back on the audio recording being discussed in elmsln/elmsln#620 )

Next step:
A record is kept of right/wrong answers and wrong answers are surfaced more frequently than those that the user has gotten right.

Vue.js has a really nice GUI for their CLI. https://blog.usejournal.com/getting-to-know-the-new-vue-cli-3-user-interface-a173b00128bd. This is an odd concept since CLI stands for command line interface, however, making complex CLI's can be really challenging. Making a list of things that have settings and operation buttons is trivial in a front-end app. In the CLI it can be a real struggle.

I've started a new branch called server that contains a new package called graphql-server. This is a graphql implementation of the cli. Basically, I wanted to see how easy or difficult it would be to expose all of the CLI functionality to the front-end. Here is a video where I walk through what that looks like. https://www.youtube.com/watch?v=Zdr-919VYEc

If we were to do this, I would think that the CLI would be responsible for running raw commands with flags, arguments and options for each command. This is absolutley necessary for automation. Then for the more complex operations where we are presenting lots of information to the user and asking them to choose settings we can leave that to the GUI. The GUI would be optionally spun up by running something like wcf ui. As long as everything is node.js based it would be nice add on to the cli.