Skip navigation
All Places > Canvas Admins > Blog
1 2 3 4 Previous Next

Canvas Admins

56 posts
Tommy Beaton

Quick Module Navigation

Posted by Tommy Beaton Feb 15, 2019

In our instance of Canvas we include all of the course modules as buttons on the course homepage. We wanted to make this buttons a little bit more accessible so I wrote some JS which scrolls to the module when they click the button and collapses all of the other modules. This makes navigating to the specific module just that little bit easier for the user. See the gif below for an example:

 

Gif to show the code in action

 

To use this, include the JS file in your current JS (you may need to remove the first and last lines of code).

 

Important: For this to work, you need to set up the button in a specific way:

  1. In edit mode on the homepage click the button (we use images for ease of use)
  2. On the right click links then open the modules drop down
  3. Click the respective module
  4. Click save!

And you're all done! Feel free to drop any bugs or edits below in the comments

When I first started using Canvas I surprised about the lack of accessibility features available to users, so i decided to create my own and to share them with the wonderful community.

 

Below I have attached some JS and some CSS too which I highly recommend that you implement into your version of the LMS. (I will happily write up a guide on how to implement it as well as how it works if anyone would like).

 

The accessibility tools below allow learners to change the text size of each custom page that you create. (Nothing native to Canvas, simply any pages, quizzes, assignments, etc that you have created).

 

It also allows the user to change the background colour of pages too (I may be implementing a text colour option soon too).

 

Clicking 'Accessibility' on the global navigation toggles the menu that you can see in the bottom left:

 

I hope this helps your instance of Canvas become more accessible and that you all find it useful  

This guide will help you setup searching shortcuts in Chrome and Firefox for finding Canvas users and courses or going directly to them using the canvas ID. Both browsers allow you to use a keyword entered into the address bar followed by what you want to search by or an ID to go directly to the resource. String placeholders (%s) represent what you type in the address bar.

 

Google Chrome

Manage search engines

  1. Click the More button and then click Settings.
  2. In the Search engine section, click Manage search engines.
  3. In the Other search engines section, click Add.
  4. Follow the directions for each search engine you want to create.

Canvas course search

  1. In the Add search engine dialog box, in the Search engine box enter Canvas Course Search.
  2. In the Keyword box enter ccs.
  3. in the URL... box enter https://<instance>.instructure.com/accounts/?search_term=%s.
  4. Click Add.

Canvas people search

  1. In the Add search engine dialog box, in the Search engine box enter Canvas People Search.
  2. In the Keyword box enter cps.
  3. in the URL... box enter https://<instance>.instructure.com/accounts//users?search_term=%s.
  4. Click Add.

Go directly to a Canvas course

  1. In the Add search engine dialog box, in the Search engine box enter Direct Canvas Course.
  2. In the Keyword box enter dcc.
  3. in the URL... box enter https://<instance>.instructure.com/courses/%s.
  4. Click Add.

Go directly to a Canvas user

  1. In the Add search engine dialog box, in the Search engine box enter Direct Canvas User.
  2. In the Keyword box enter dcu.
  3. in the URL... box enter https://<instance>.instructure.com/users/%s.
  4. Click Add.

Activation

To activate the search engine enter the search engine keyword in the address bar, and then press the Tab key, and then type your search string or ID, then press Enter.

Firefox

Create bookmarks folder

  1. Click Library, then click Bookmarks, or press Ctrl+Shift+B
  2. In the Bookmarks list, right-click on Bookmarks Menu then click New Folder....
  3. In the New Folder dialog box, enter Canvas Search in the Name box, then click Add.
  4. In the Canvas Search folder right-click and select New Bookmark....

Canvas course search

  1. In the New Bookmark dialog box, in the Name box enter Canvas Course Search.
  2. In the** Location** box enter https://<instance>.instructure.com/accounts/?search_term=%s.
  3. In the Keyword box enter ccs.
  4. Click Add.

Canvas people search

  1. In the New Bookmark dialog box, in the Name box enter Canvas People Search.
  2. In the Location box enter https://<instance>.instructure.com/accounts//users?search_term=%s.
  3. In the Keyword box enter cps.
  4. Click Add.

Go directly to a Canvas course

  1. In the New Bookmark dialog box, in the Name box enter Direct Canvas Course.
  2. In the Location box enter https://<instance>.instructure.com/courses/%s.
  3. In the Keyword box enter dcc.
  4. Click Add.

Go directly to a Canvas user

  1. In the New Bookmark dialog box, in the Name box enter Direct Canvas User.
  2. In the Location box enter https://<instance>.instructure.com/users/%s.
  3. In the Keyword box enter dcu.
  4. Click Add.

Activation

To activate the search engine enter the search engine keyword in the address bar, and press the Spacebar, and then type your search string or ID, then press Enter.

Examples

  • Canvas course search: ccs Sp19 BIOL-1010

  • Canvas people search: cps Abe Froman

    • You can also search by login_id, email, or sis_id.

  • Go directly to a Canvas course: dcc 123456

  • Go directly to a Canvas user: dcu 123456

A long, long time ago, in an office somewhere in my building (I'm guessing), a conversation probably nothing like this took place:

vintage secretary

 

"Okay, it's time to implement the new LMS, Canvas."

"Hooray! Anything special we need to do?"

"Well, we should probably decide if our Canvas instance should be one big bucket of stuff, or if we need sub-accounts for our 5 separately accredited colleges."

"I'd think sub-accounts by college would be smart!"

"Definitely. Oh... wait... We're integrating Banner with Canvas, right?"

"Of course!"

"Well, we have Banner set up to essentially treat our district as a single entity."

"And?"

"Well, there's no easy way to tell Canvas which sub-account the course should be in."

"Oh. One giant bucket, it is!"

 

Fast forward a year or two. The transition from Blackboard to Canvas is complete. Faculty adoption is growing rapidly. Online course offerings are expanding. Requests for adding account-level LTIs keep coming. Data and outcomes and analytics are hot topics. People begin to question with more regularity why we don't have sub-accounts to keep these things useful, streamlined, and logical. The answer continues to be "because we don't have Banner set up in a way that makes sub-accounts possible". Fast forward a few more years. People are asking at least weekly why we can't do a thing that can't be done because we don't have college sub-accounts. The requests finally prompt action. The action hits numerous brick walls. There is a script written that seems to solve the problem by moving the courses from the root account to the correct sub-account after the fact. Testing is going well. There is dancing and singing. Then someone performs a section sync in Test Banner, and the course in Test Canvas gets thrown out of its sub-account and back to the root account. Canvas insists that "account" should be sticky. Testing continues to prove that Banner is a jerk and refuses to listen to what Canvas says. Other avenues are considered and defeated. Tears are shed. And here we are, seven long years into our Canvas adventure, without any hierarchy whatsoever. And we've exhausted every reasonable idea, short of demolishing the entire Banner > Middleware > Canvas structure and starting from the ground up.

 

cartoon guy at computer

 

So what's the point of my blog post / stream of consciousness rant / discussion prompt / cautionary tale / plea for help? Well, first, my words of advice:

  1. If you are new to Canvas, consider your account/sub-account structure, very very very carefully.
  2. Canvas is a wonderful company full of wonderful people, but they do not have expertise in your SIS of choice, so make sure your SIS of choice is ready and willing to work with you on establishing (and maintaining, and adjusting as needed) a good integration with Canvas.

 

And my points of discussion:

  1. I know people have created a sub-account structure "after the fact". What makes our situation challenging is the way we set up Banner. We are unable to change how Banner is configured.
  2. We have had various vendors swear they can help us using APIs. This may be true, but they neither understand our Banner setup nor possess actual, practical, deep Canvas knowledge.
  3. We are still using Luminis Message Broker as our middleware. My understanding is that LMB is an outdated tool. But the alternatives (Ethos, ILP) are described to me as not mature enough, not robust enough, and/or possibly not compatible with our current portal (or version of).
  4. We haven't completely ruled out turning off real-time events and doing automated batches. BUT we have a bazillion (actual number) Banner users across our 5 colleges who would need to be re-educated on new processes and that is... daunting.

 

The plea:

  1. Is there anyone out there that knows Banner really well AND knows Canvas really well AND is not already working full time for a Banner/Canvas institution? We have tried the "hire a consultant" route, and a creature with such expertise (in the land of hire-able consultants) appears to be rarer than a 3-legged unicorn.
  2. Has anyone had a similar situation and come up with a miracle workaround that they'd be willing to share? I will pay you in cookies and a coffee mug that says "You're Awesome!" [side note: don't search Amazon for "You're awesome" coffee mugs. Someone apparently decided not to stop there and made all the mugs NSFW]
  3. Please consider this an open discussion, and throw any ideas into the comments, no matter how wild and insane they might sound. Tag any groups or spaces I missed, or any smart folks who might know something, anything. It's possible there will be points for creativity, but it depends on whether I'm continuing to lose ground in the Community. I once made it to 17th. Those were the days.

 

Thank you in advance, Canvas friends!

 

unicorn

 

Also tagging Canvas Developers Instructional Designers Higher Education Higher Education SIS

There have been some important changes to developer keys (see the 14 Jul 2018 and 10 Oct. 2017 release notes) since my last blog post about what administrators should consider when issuing developer keys. Through feedback from the community and from our clients, I’ve noticed there is a lot of confusion surrounding developer keys in general, and specifically surrounding the Instructure-issued developer keys that appear in the “Inherited” tab of the Developer Key Management UI. This blog post should hopefully answer many of the frequently asked questions surrounding developer keys and give Canvas Account Administrators a deeper understanding of how to best manage developer keys.

Dev Keys overview

A developer key allows an application to request access to a users API information. In all cases, the user must authorize the application to act on his/her behalf. If the user authorizes an app, Canvas generates an API token and securely responds to a request from the external application with the generated token. The app can then store that token and use it to perform the API requests that it has access to. You’ve probably seen this in the UI (see image below), but may not realize that a developer key is involved:

  An example of the UI shown when a developer key to requests access to a user's Canvas API

 

Types of Developer Keys

There are two types of API developer keys: account-bound or inherited (this may also be referred to as a global developer key).

Account-bound developer keys are issued by the Account Admin and will only be able to request API access from users that belong to that account.

Inherited developer keys are issued by Instructure based on a basic set of criteria (see our API docs under the “What management features are available?” section) and can access any account where they have been enabled.

History

Understanding the history of developer keys in Canvas will help you understand your current list of inherited developer keys.


Before October 2015

Account-bound Developer Keys did not exist, so if a vendor wanted API access, we had to work with them to issue a global/inherited developer key. As you can imagine, this raised concerns, so a series of releases (19 Sept 2015, 10 Oct 2015, and 31 Oct 2015) allowed developer keys to be account-bound and managed by the Canvas Account Administrator for each institution.

October 2015 to July 2018
Vendors had to work with each institution they integrated with to obtain a developer key. They also had to manage multiple developer keys inside of their application. Instructure severely limited its issuance of developer keys and pressured vendors to work with individual institutions to obtain an account-bound developer key. Inherited developer keys were only issued In rare cases where they seemed like only reasonable option and where Instructure had a very strong partnership in place.

Canvas Account Administrators raised legitimate concerns over the level of access that developer keys had (the API token issued had access to every API endpoint the user had permission to access). Furthermore, they had no way to know which inherited developer keys had access to their accounts, let alone the approval process by which Canvas issued the developer keys, without reaching out to their CSM.

July 2018-present
In response to the concerns raised by our customers, we released a set of features (14 July 2018 and 10 Oct. 2017 releases) that allow for admins to manage which inherited keys have access to their accounts. Furthermore, developer keys can now have their access restricted through the use of developer key scoping.

Instructure began issuing inherited developer keys, simplifying both the management of developer keys for application owners and reducing the steps required to enabling developer key access for Canvas Account Administrators.

Default settings for inherited keys

Simply put, developer keys issued prior to July 2018 were defaulted to ON, since we wanted to avoid breaking any existing integrations. Developer keys issued after that default of OFF so that a Canvas Account Admin must approve and enable the developer key to have access to their account.

Instructure’s approval process/vetting for Inherited Developer Keys
Many admins have been surprised at the number of developer keys that they find in their “Inherited” tab, spurring (rightly) many questions related to how they got there and what processes are in place for approval. The previous section should help understand the how they got there aspect for anything issued before July 2018, but may want to know more about the current policy that Instructure takes when issuing a new developer key.

As mentioned previously, we (the Partnerships/Platform team) issue developer keys based on a basic set of criteria (see our API docs under the “What management features are available?” section).  I’ll flesh this out in a bit more detail here:

What Instructure does:

  • Requires scope enforcement for newly issued inherited developer keys.
  • Requires justifications for why those scopes are needed.
  • Requires explanations of how developer keys and tokens are securely stored.

 

  • Expects Canvas Account Admins to determine their own vetting policies and apply them when enabling an inherited developer key.

 

What Instructure likes to have:

  • A basic product demo showing the integration. This is pretty much required for anyone who doesn’t have a partnership with us.
  • Links to relevant documentation about the integration.

 

What Instructure does not do:

  • Thoroughly examine the application’s code base
  • Audit security. privacy, or storage policies for the application. As noted above, Instructure expects Canvas Account Admins to determine their own vetting policies.
  • Ensure that the application will comply with all of our customers various integration policies.


Best practices for managing inherited developer keys as a Canvas Account Administrator

As a Canvas Account Administrator, you are the gatekeeper for which applications have the ability to request API access from users in your account. That’s a lot of responsibility, but fear not, I can help.

The first thing your should do is audit which developer keys have already been used to issue tokens in your account. The best way I have found to do this is by running the User Access Tokens report. You can then look at the “dev key id” column and make sure those are all turned on.

 

Next, Once you have the report, use whatever internal policies or processes you may have to determine if each of the developer keys is appropriate for your organization. You might consider doing the following:

  • Determine who (at your organization) requires these developer keys / access tokens
  • Check if these are still actively being used, and why
  • Determine why these are being used (and document these reasons)
  • Approve the continual use of these

 

Next, You can turn off any of the inherited keys that don’t appear in the report, but you may want to check with any of your internal teams to verify. There may even be someone who already knows which integrations are currently being used. Just know that if you turn off a developer key for an integration that depends on it, you will be limiting it or completely breaking its functionality. Note that a key can be turned on again in case of error.

 

Last (optional) you may want to reach out to others (admins, teachers, students etc) to keep an eye out for any errors related to integrations that throw authorization errors just in case you made a mistake.

 

That’s it! You’ve now limited access to only those keys that your account is dependant on. When you work with a new vendor that has an inherited key, you can now push them through whatever vetting processes your institution may have in place and then enable their inherited dev key.

 

A note about scope enforcement

Using scoped developer keys requires some work by the vendor that uses the developer key. They must determine the scopes they need access to and modify their OAuth2 request to include the scopes they want access to. Furthermore, some applications use “include” query parameters in their API requests. Canvas scoping ignores these parameters, so they must come up with alternatives API endpoints to more explicitly obtaining the same information. Our Partner Support team is happy to help our partners create a roadmap toward this end, but it’s up to our clients to put the heat on while understanding the technical challenges that they face.

Roadmap: Developer Key Experience Improvements

The Canvas API integration experience can be better. I’m currently scoping out requirements to enhance the developer key experience. I have some ideas in mind (ex: exposing the scopes for Inherited developer keys to Canvas Account Admins), but I’d rather hear your ideas to make sure mine are as good as I think they are! If you have an idea for an experience enhancement or any other ideas related to developer keys, please follow the Feature Idea creation process and throw a link to the feature idea in the comments! Make sure to review the comments and open feature ideas to make sure there isn’t one already open that addresses your idea.

 

Conclusion
I hope that this blog post has helped our Canvas Account Administrators understand more about all the recent changes to dev keys and how best to user their new shiny developer key management UI. Happy vetting!

 

FAQ

Q: "If we disable these inherited keys, do we in effect become a gatekeeper to individual instructors being able to install an app for their course?”
A: Yes. Instructors must work with their Canvas Account Administrator to turn on any inherited developer keys before their course-level integration that depends on it will work.

 

Q: "Where do the Inherited Developer Keys originate?"

A: Instructure issues them. See the “History” section above for more info.

Q: "Are there any best practices recommended for ensuring a higher degree of security?
A: The same recommendations that are outlined in my previous blog post should help here, but there are no specific Instructure defined “best practices” that will work for everyone. Talk to your technical folks at your Institution, or your network of professionals to see what they think is best on top of what I’m presenting here.

 

Q: “Does allowing the inherited keys to remain enabled cause any unintended data to be sent to these vendors?
A: Only if the vendors requests access to data and the end-user authorizes access. Most vendors have an LTI integration that is required before the app will even ask for authorization, so if it’s not installed, chances are you can safely turn the integration off. That said, there are API based integrations that don’t require an LTI component.

 

Q: “How do I know which developer keys are being used in my account?”

A: Run the User Access Tokens report and examine the “dev key id” column. If a dev key has been used to issue an API token for your account, it should appear here.

Recently two courses had actual enrollments that exceeded the physical capacity of the classrooms where they were scheduled. I am thinking about writing a tool that would use the student registration data for each Canvas course to compare against the seating capacity of the classrooms that have been assigned to this course.

 

The basic idea is to use the Canvas API to get the enrollment data, then get the scheduling information (from TimeEdit), then get the classroom data via a local API that gives information about each classroom (including seating capacity for classes and exams). Ideally, this should be able to notify the responsible teacher and the scheduling office when there are too many students for the planned classroom. [Yes, I am aware that many universities avoid this problem either with very good pre-registration systems or via setting caps on the number of students who can enroll in a course. Unfortunately, locally the first is unavailable - scheduling happens almost 6 months before the course, while the latter is possible - it is undesirable.]

 

Has anyone already used Canvas in this way?

 

The above is a potential tool that I am considering for a potential project "More tools for Canvas: Helping to simplify the life of students and teachers" - my goal is to devote ~50% of my time for a year (2019) to create tools to support e-learning activities at my university.

 

A first subproject in the above project is a tool to provide an interactive quiz to collect data for students planning to start a degree project, with the goals: (1) eliminate a paper form, (2) ask only the minimal set of questions necessary, (3) automatically enter this data into custom columns of a gradebook, (4) greatly simplify life for students, teachers, and administrators, and (5) as a part of a process to streamline the entire process from a student submitting a proposal for a topic to the student completing their thesis (with oral presentation and final approved thesis).

Being at an institution with a number of experienced Canvas users as well as many just getting started, I have been giving thought to what activities within the Community should be included in initial certification and re-certification courses. I’m sure that many of you have either developed or have considered developing similar training of your own.


The Community and its wealth of resources undoubtedly should be a part of this teacher professional development, but with so many ways to be involved what should training cover in terms of key “do’s” and “don’ts”? There are certainly activities that could be a part of certification or re-certification programs that are effective in fostering Canvas (and general teaching) knowledge as well as other activities that are not as effective for individual teachers, or the greater Community as a whole.


Working with teachers myself as well as others within the Canvas Community, I believe the following is a good list of do’s and don’ts when it comes to teacher training on the Community.


The Do's:


1- Do have teachers join a Community Group (or several) with individuals that share a common interest
Groups are a great way to collaborate with peers and share questions and ideas. Knowing what groups are available, how to join a group, and what resources are available in group spaces is valuable to teachers of any experience level. Group information can be found at Join Groups 


2- Do have teachers find a helpful post within the Community and share this with a colleague

When searching through the Canvas Community, we often run into information that could help other teachers at our institution. In addition, if there is a feature idea that we believe would improve Canvas, we can share the idea with those who may choose to vote it up as well. Sharing content is a great way we can encourage a culture of continual learning and collegiality.

3- Do have teachers answer a question someone else posted within the Community

One of the greatest benefits of the Community, in my opinion, is the opportunity to get insight on questions from Canvas users around the world. Have teachers in certification/re-certification courses search the Q & A section of the Community for unanswered questions. If there is a question an individual can answer, have them do so linking to Canvas guide pages for relevant information and perhaps even including a screenshot if appropriate. Even if a question has been answered, often others can add to the answer by posting links to supplemental material in the Community (related Feature Ideas, Blogs, Discussions, etc.). It may not always be evident, so it would be worth reminding teachers new to the Community that students as well as teachers post questions.

 

4- Do have teachers find an interesting discussion (or blog, question, etc.) and add a response that moves the topic forward

With such a wide variety of individuals in the Community, rich discussions often result from peers sharing their personal experiences and insight. Locating a topic the teacher finds interesting, reading the threaded responses, and continuing the discussion benefits not only themselves but also everyone else in the Community!

 

5- Do have teachers give someone a badge!

Badges are a great way to recognize someone for a great post, idea, or contribution in the Community. Have teachers find a Community member they believe deserves a badge and award them this recognition.  For more on awarding badges, see How do I give a badge to another user in the Canvas Community? 

 

6- Do have teachers consider attending an event

Those new to the Community, and perhaps even teachers who have been members for some time, may not realize the events they can attend to further their knowledge of Canvas and get great ideas for enhancing classes (see CanvasLIVE). Ask those in a Canvas certification/re-certification course to locate an event they find interesting and register to attend.

 

The Don’ts:


1- Don't have teachers post a Feature Idea 

Feature Ideas and the voting/discussion that happens within these pages is extremely valuable, but duplicate ideas often do more harm than good. Not only may some individuals vote on one idea and not another, but important discussion about the idea may be missed by someone reading only one of the pages.  Posting a feature idea isn't advisable unless someone has searched existing ideas to ensure another isn't already open.  A better activity for training purposes may be to vote on, share, or provide additional insight into an existing idea. 

 

2- Don't have teachers post a question to the Community Q & A (if the question can be easily answered using the Canvas guides)

Rather than asking teachers in certification/re-certification to post a question, a more effective approach would be a task that demonstrates their ability to search existing content for answers or ideas.

 

3- Don't have teachers post a question to the Community Q & A (without first checking whether someone has previously asked the same question and had it answered)

Most teachers will come across questions with Canvas at some point. It has been surprising to me how often when I have questions, I find that someone has already posted this in the Community and someone else provided an answer. Duplicate questions have many of the same issues as duplicate Feature Ideas so again, an activity involving searching content may be more effective than one asking to post a question.

 

There is certainly a great deal more that teachers could dive into as they learn more about what is available within the Community. Personally, I first came to the Community to read what questions others had about Canvas and learn the answers. The more time I put into the Community, the more ideas I found that improved my classes and those of the teachers with whom I work.

 

At my institution upcoming training with teachers on Canvas, and the Community specifically, will center around the do’s and don’ts above. It would be interesting to hear from others on these ideas.


It would also be interesting to hear if anyone has student Canvas training that requires participation in the Community and if so what type of participation is required. I believe that many of the same do’s and don’ts above (particularly don’ts) could apply to Canvas training for students as well as teachers.


Thanks and best wishes!

The Services Department released Be the Hero: Canvas Admin Quick Start Guide in October 2018 as a free resource for new Canvas admins. The blog post announcing Be the Hero is here. You can find the course in the Canvas Commons.

 

We'd love to hear how you're using it!

 

We will update this blog as the resource grows and changes. We invite you to share, ask questions, and tell us how you're "Being the Hero"

 

Please comment below. We’d love to hear from you!

Knowing where to begin as a brand new Canvas Admin can be a huge task. You probably need to move quickly, and learn a lot all at once. We've created a new free resource - Be The Hero -  for you to help you get acclimated to how Canvas works and how it can work for you!

 

About The Course

Be The Hero has five modules of content that will take those who will be Canvas Admins through everything they need to know about using Canvas at their institutions - no matter what level. The course uses a combination of the Canvas Video Guides and Canvas Guides to teach the content. Each concept also includes information about the corresponding Canvas Training webinar. Participants in the course will have the opportunity to check their understanding with self-check quizzes at the end of each module. 

 

 

The course is available in the Canvas Commons at this link: Be The Hero, (pro tip - make sure you're logged in to Canvas!) and is offered under a Attribution-Non-Commerical-ShareAlike licence. That means you’re free to share the course, as well adapt it to meet the needs of your institution.

 

If you’ve never used a resource in the Canvas Commons before, all you need is an empty course in your Canvas instance in which to copy the Growing with Canvas course. Once Be The Hero is in your instance, you’re free to edit and use the course as you wish. Check out this guide - How do I use Commons? - if you need more help.

 

UPDATE 10/30/2018: If you don't have the Commons, or if you are having an issue with downloading the course from the Commons, visit this link (BeTheHeroOct3018.zip - Google Drive ) instead to download a copy of the course. Simply then have a blank course in your instance of Canvas to import the course to, and you'll be good to go!

  

Potential Uses

  • Share this course with your colleagues
  • Apply the principles in Growing with Canvas to your own courses
  • Elevate your knowledge about Canvas

The terms list on the account-level course page is sorted in ascending order. When I filter terms, I almost always want the current term or a recent term. Having to scroll to the bottom of our long list of terms is annoying, so I wrote some JavaScript (with the help of Stack Overflow) to sort the list by term ID in descending order. In case anyone else might find this useful, here it is:

 

if (window.location.pathname.indexOf('accounts') > -1) {
    // https://stackoverflow.com/questions/20693593
    var selectOptions = $('select optgroup[label="Active Terms"] option');
    selectOptions.sort(function(a,b){
        return parseInt(b.value) > parseInt(a.value);
    });
    $('select optgroup[label="Active Terms"]').html(selectOptions);
}

 

(I welcome tips for improvement, JavaScript aces!)

In my recent efforts to migrate data into Canvas from another reporting system one of the things that I found useful was to enroll all the users into the course and set their state as active, but for students who should not have access to the course (because they have taken a leave, quit, have an administrative hold on course participation, ...) - after adding their data to the gradebook - simply set their state to inactive (deactivate the student).

The code below shows how to do this in python:

def deactivate_user(course_id, enrollment_id):     global Verbose_Flag     #Request Method: POST     # DELETE /api/v1/courses/:course_id/enrollments/:id     # Scope: url:DELETE|/api/v1/courses/:course_id/enrollments/:id     # Conclude, deactivate, or delete an enrollment. If the task argument isn't given, the enrollment will be concluded.      url = baseUrl + '%s/enrollments/%s/?task=deactivate' % (course_id, enrollment_id)     if Verbose_Flag:        print("url: " + url)      r = requests.delete(url, headers = header)     if Verbose_Flag:            write_to_log("result of put of reactivate: " + r.text)     if r.status_code == requests.codes.ok:        page_response=r.json()        if Verbose_Flag:               print("deactivated {0} in course {1}".format(enrollment_id, course_id))        return True     else:        if r.status_code == 404: # "404 Not Found"               write_to_log("status code: " + str(r.status_code))        else:               write_to_log("status code: " + str(r.status_code))     return False 

One surprise in doing the above is that one has to use the student enrollment_id and not their user_id. One can find this enrollment_id with:

def active_user_in_course_by_user_id(course_id, user_id):        # Use the Canvas API to get the list of users enrolled in this course        #GET /api/v1/courses/:course_id/enrollments        # user_id string     Filter by user_id (only valid for course or section enrollment queries). If set to the current user's id, this is a way to determine if the user has any enrollments in the course or section, independent of whether the user has permission to view other people on the roster.         url = baseUrl + '%s/enrollments' % (course_id)        if Verbose_Flag:               print("url: " + url)         extra_parameters={'user_id': user_id,                          'enrollment_type[]': 'StudentEnrollment,TeacherEnrollment,TaEnrollment,DesignerEnrollment,ObserverEnrollment',                          'state[]': 'active'        }        print("extra_parameters={}".format(extra_parameters))        r = requests.get(url, params=extra_parameters, headers = header)        if Verbose_Flag:               write_to_log("result of getting enrollments: " + r.text)         if r.status_code == requests.codes.ok:               page_response=r.json()               return page_response        return None

In conjunction with migrating users from one source to another (such asMigrating grades from one Canvas course to another ). I found it useful to be able add users based on their SIS ID and to be able set them to inactive or reactivate them.

The results are python programs to enroll a user:

enroll_person_in_course_by_SISID.py course_id SISID role

and a program to inactivate or reactivate the user:

set_enrollment_state_of_SISID_person_in_course.py course_id SISID state

 

Examples with pictures and code are at activating and reactivating users: Chip sandbox 

Notes

Initially I was enrolling the user with a given state, but this has the undesirable side effect of putting them in the default section and not just changing their state (if they are already enrolled). Looking at what the GUI sends when deactivating and reactivating a user let me to the solution adopted in the two programs above. The main gotcha was that you have to use the enrollment_id and not the sis_id or user_id, this means that given the user's SIS ID you first have to lookup the user to find their enrollment_id. Unfortunately, the GET /api/v1/courses/:course_id/enrollments state[] parameter does not seem to support an array of values, but rather has to be a string with one of the values; this means that one has to lookup inactive users separately from active users. It would be desirable if the state could be a vector of values or is there was synthetic state "all". Even more confusing as the parameter name is state[] , which to me suggests that it has an array value.

 

Background

Now what caused me to do the above? A question came up about what to do with users that could be migrated, but whose status was that they had interrupted their studies in the course or for some other reason could not complete the course.  I would like to thank Brian Neporadny for his answer in When do you archive / remove / disable users and content?  that lead to exploring the idea of adding these users, adding their grades, and then setting their state to inactive. In this way the instructor can see the grades of the student for those assignments that did have a reported result, while not allowing the student access to the course. [For testing purposes it was useful to be able to reactivate a user after setting them inactive.]

My recent attempt to migrate users' grades for assignments from a pre-Canvas course to Canvas starts by adding the users to a Canvas course, then adding the assignments, and then finally adding each student's grade for each assignment.

 

Of course such a program requires testing. This testing creates lots of enrollments for users. In order to run the program again it is very convenient to remove these users. Similarly there is a need to remove the created assignments. Hence I wrote two scripts:  (1) to remove users (except for myself) and (2) to remove all assignments.

 

You can find the code for them at Removing other users and assignments: Chip sandbox .

 

One of the small gotchas that I found is that to remove a user from enrollment in a course you need to use the user's enrollment_id and not their canvas_id.

In the first several year of using Canvas I spent a lot of time moving content (especially quizzes) from the prior LMSs, but this is my first major attempt to move state information for students. Has anyone else addressed such a migration?

 

In this migration effort, I need to move records of students' grades from another system into Canvas. Many of these students have partially completed an earlier course round (a specific session of the course) prior to the introduction of Canvas and now need to complete the remainder of the requirements for the course (for which they will have to register for a new course round that will be in Canvas).

 

One difficulty was that these grades were from a number of different grading systems (more than a dozen of them). One of my colleagues suggested a grading standard that would capture all of the different grades (a unified grading standard), so that when looking at grades in the gradebook for each assignment you would see the original grades. In this way a teacher could see which parts had already been completed by the student and which parts remain, and then act accordingly.

 

I was pleasantly surprised at how easy it was to add the new grading standard, but do not yet know what unexpected repercussions will occur by using it. For those who are interested in examples and the program that puts the new grading standard into a course or account, see Grading standard: Chip sandbox .

 

As a side question is there anyone who has used an ECTS A-F and Fx grading standard or the corresponding Pass/Fail grading standard for their institution? I am a bit surprised that both of these do not come as predefined grading standards for an LMS used in Europe. 

 

In a subsequent blog post I will report on my migration effort via experiments in enrolling students into a Canvas course, adding each of the assignments from the earlier course round, and then populating the gradebook with grades.

Neal Shebeck

CCSD - Sharing the Love

Posted by Neal Shebeck Apr 11, 2018

I never know when I should be doing a blog post, document, discussion, etc. but this just felt like a blog ( I think ). While the Clark County School District is pretty massive (over 44,000 employees and 318,000 students) our core group of Canvas people is quite small. A majority of management, development, and support comes down to just 3-4 people. We have shared some things in the past like templates for courses and templates for "conference-style" courses in commons but we haven't shared too much code in the past. 

 

Over the last 2-3 years we have been expanding our hacks of Canvas to try to increase adoption and respond to teacher and student needs. While we have created some very cool things we find that getting feedback from other developers and users is what we're lacking. In an effort to expand our reach for collaboration to other districts and higher ed, we have decided to start sharing more. To that end Robert Carroll has recently posted a couple things to github that we have found helpful. Hopefully you will too.

 

Create a "Workroom"

We don't let our teachers create courses on their own but we found the need for our teachers to make practice courses for themselves if they were going to leverage Commons, professional development, or just to play around and experiment with Canvas. We managed to do this by:

  • Making sure every employee is a teacher in one "workroom", giving them the teacher role
  • Turning on the ability to create courses for "teachers"
  • Hiding the button to create courses from them
  • Coding a link that creates the additional workrooms for them (and adds them as the teacher)

Check out Robert's post on how we did this.

 

Sub Account Menu

We have a lot of sub accounts (8,090 and counting). When you're a top level account admin and have more than  even 20 sub accounts, you may find yourself frustrated with navigating to the one you need. This fixes that... big time. Yes, it only helps about 8 people, but speaking as one of those eight people, I love it! Plus, if you save account admin time, that equals quicker support for your users.

See how this was accomplished and get the code for yourself.

 

When we share something else, I'll be sure to update. In the meantime, hope to see you in the community and at InstructureCon!

 

---Update (4/26/18)---

 

Global Nav - Custom Tray

There were several institutions that lost the functionality of some custom "pop out" menus from their global nav after a Canvas recent update. Robert worked on that, (starting with some code he credits in his post), and posted a solution over in the developers area.