Using FFT Canvas to track scout rank advancement

I have been a 11-year-old scout leader for almost 2 years now and have been looking for an easier way to track what my scouts have accomplished along their pathway to rank advancement. I have looked at a few other tracking systems in the past, but the cost of the system, though not particularly steep, seemed to be the sticking point. We currently track our scouts by photo-copying the rank requirement pages and signing off those and then once a month we update the scout’s handbook so its current. The problem we have is there is only one set of records and usually parents will contact me or the other scout leader about where their scout is and we sometimes don’t have that information handy or have to send them to the other scout leader.

Being a Canvas administrator I realized I had a great platform and mobile apps to track this information and give access to the other scout leader and possibly the scout’s parents, the last part is a bit ambitious so I am focusing on tracking first then add the bells and whistles later. I logged into my FFT Canvas account and created a new course and set about devising how I could track this information.

In Utah 11 year-old scouts, (Blazers to us old enough to remember), focus on getting through the rank requirements before they turn 12. So in short order we try to get them through their Scout, Tenderfoot, Second class, and as much as or all of First Class rank requirements. Usually we try to run through all the requirements in 6 months so we can repeat the process twice a year to ensure all scouts have an opportunity to pass of the requirements. That’s a lot of information to track and coordinate in a short amount of time, and it seems like a good plan in theory but executing that plan is a challenge, so tracking is vital especially when we need to hand that information off to the 12-year-old leaders to continue helping them advance.

Planning

I weighed the different options of how to track the scouts and determined the fastest way to get started was to use complete/incomplete assignments for each requirement and organize them in assignment groups according to the rank. I wanted to have the assignment have the basic requirement information so I wanted to name them based off of the requirement number, (i.e 1a, 1b, 2), and the requirement description be the assignment description. Now I needed a way to get them into a usable format.

The Boy Scouts of America had a handy PDF of the current requirements for download so I was able to copy and paste them into a text editor to manipulate them into a format I could utilize. It took a lot of cleaning up, but I was able to get them into a readable format. I first created basic text files of each rank requirements and then set out to determine how best to get them into Canvas, to semi-quote Liam Neeson from Taken, “…what I do have are a very particular set of skills [with the Canvas API and Python].”

Creating 120+ assignments by hand and adding them to the correct assignment group was not something I was willing to do, I had already spent several hours cleaning up the text, so I turned to the Canvas APIs to create the assignments. I first created the assignment groups named after each rank and using the API got each assignment group ID for the next step. The easiest way for me to do this, would be to create a CSV file of the rank requirements split up into the assignment name, description, type, group, and point value. I would then write a Python script to take the values from the CSV file to create an assignment for each requirement and place them into the appropriate assignment group. Turning the text files to CSV did take some time but I had warmed up the regular expression part of my brain and was able to get it done much faster than the text cleanup. I ran the script for each rank and had the assignments created within a few minutes.

canvas_scouting_assignments

Users

My next challenge was what to do about the scouts? My answer came in a sneaky hack Google added into their Gmail system. You can take any Gmail, Google apps, or Google apps for education address and before the @gmail.com or other domain put +whatever to piggy back a unique email address off your own account. So if I was Liam Neeson and had a FFT Canvas account under the Gmail address of liam.neeson@gmail.com I could use liam.neeson+fatheroftheyear@gmail.com to create another user account in FFT Canvas and it would still send emails to liam.neeson@gmail.com but still be a unique address to Canvas. Using this little hack in Canvas FFT I created accounts for each of my scouts that pointed back to my email address.

Putting It into practice

I finished it in time for our troop meeting and I logged into my FFT account using both the mobile app and SpeedGrader on my phone. From there I was able to use the attendance tool and the SpeedGrader to mark the requirements we went over that night as completed for each scout. It was very easy to use and I even got the other scout leader setup with his own account and he installed the mobile apps as well so he has access to the same information. I also accepted the invitation for each one of my scouts which allows me to use the gradebook CSV to bulk enter their requirements.

screenshot_2016-11-02-16-14-48 screenshot_2016-11-02-16-14-04 screenshot_2016-11-02-16-13-46

Future enhancements

I have been sharing it with others I work with that are involved with scouts and they offered some suggestions that I am going to consider implementing. Some of the suggestions include:
• Tracking campouts, activities, service project hours, etc…
• Adding the parents as observers to their scout so they can see the progress at anytime
• Changing the default email address of the scout’s account to one of their parents so I can use the communications tools in Canvas
• Turning some of the requirements into an online submission assignment where the scout has to provide evidence of their requirement completion
• Incorporating Rubrics and/or Outcomes for requirements that need demonstration of understanding

This was quite a fun project to get going and it also gave me another valuable script that I can use at work if needed. I will post the course in Commons so that anyone can use the course and feel free to make changes and improvements or if you have suggestions of your own feel free to contact me anytime.

Create a Python Config File for API Scripts

A best practice you should adopt is storing sensitive information used in scripts in config files rather than directly in the scripts. This helps ensure a few important things:

  1. It is easier for you to make changes when you only have to change one file rather than multiple files.
  2. You can reference different configuration items like the production, beta, and test URLs of your Canvas instance. In my configuration file I have tokens for different roles and permissions as well as the different instance URLs.
  3. You are less likely to accidentally leak sensitive information. This is very important when you use a version control system, such as GitHub to share or archive your scripts. Unless you pay for a Github subscription to have private repositories, your code is publicly visible. There are people and groups constantly scanning Github and other publicly available version control systems for API tokens, keys, secrets, usernames, and passwords for exploitation. Luckily most version control systems include a way to ignore or prevent certain files from being uploaded to a repository. So you will want to add any config files containing sensitive information to that ignore list.I use Python 3 as my go to scripting environment and a few years ago I adopted the use of configuration files using the configparser module https://docs.python.org/3/library/configparser.html. One of the greatest strengths that configparser has is the ability to separate key value pairs in sections. In my config file I have an instance and an auth section. The instance section contains the different Canvas instance URLs appropriately named prod, beta, and test.
[instance] 
prod = https://abc.instructure.com 
beta = https://abc.beta.instructure.com 
test = https://abc.test.instructure.com 
catalog = https://catalog.abc.edu 
[auth] 
token = 1234567890…… 
teacher_token = 0987654321….. 
student_token = 9045387230…..

You can name this anything you want, have any extension you want, and place it anywhere as well, e.g: config.ini, config/secrets.cfg. If you manage multiple instances you could create separate config files for each instance containing the different URLs and any tokens you need access to. In the event that a config file may be leaked or exposed, it will be isolated to that one file.

The code below is how I reference the config file, it makes it very convenient to drop this block of code into a new python file and I am ready to make some API calls.

from configparser import ConfigParser 
config = ConfigParser() 
config.read('config/config.ini') 
token = config.get('auth', 'token') 
domain = config.get('instance', 'prod') 
headers = {'Authorization': 'Bearer {}'.format(token)}