Custom Reports in Planning Center Online

If you work or serve in a church, chances are you use Planning Center Online a lot. We use their Services product to plan and organize our weekend services, schedule volunteers, etc.

Even though they have a mobile app and desktop interface, we still rely on printed reports on the weekend. It’s simple, fast, we don’t have to worry about the internet going down, the team members can write all over them, etc.

Out of the box, Planning Center comes with some great reports that you can print out. They can somewhat tailored to your organization with your church’s name or logo, etc.

Screen Shot 2018-05-02 at 8.33.53 AM
Here’s an out of the box standard report. It gets the job done but it could be better.

In addition to their standard reports, they also support custom reporting. If you know a little HTML, CSS, and are ready to learn some custom tags, it’s pretty easy to jump right in.

Screen Shot 2018-05-02 at 9.29.14 AM
Here is a screenshot of a custom report. You can see the HTML and CSS, along with the custom tags that help to generate the report. You can see that some variables have been created and are then referred to later in the document.

The reporting language that PCO uses is called Liquid. If you want a good resource to read that is outside of what PCO offers, here is one.

Liquid is an open source templating language that allows you to do simple conditional and iteration along with filters to parse and control the page as it loads. What this means for you as a user is that you have a lot of simple power at your fingertips to create custom reports designed for exactly what you need!

So, with these tools, I have created several custom reports that our teams use when it is time to print out paperwork for weekend services.

The report I use most often is for our tech team. It prints out a customized version for every person serving on the team that weekend, with their name, the general service flow, and information just for their position, notes, checklists, etc.

 

Screen Shot 2018-05-02 at 8.35.16 AM
Here is an example page from the report. Every team member gets a page (or pages as needed) with their name and customized information for their position.

 

The nice thing about this report is that I only have to run it once and print once. It creates a new page for every person on the team, so I don’t have to remember how many copies I need to print – I just print the whole file and it has exactly what each person/position needs!

This report includes custom plan item notes per position. To add those, just add a plan item with an item note named:

Position Name

The name has to match exactly. The report also includes overall plan notes per position. To add those, just add plan notes like this:

Team Name – Position Name

When you add your plan notes or plan item notes, just type something specific in that field and only that position will see it when it prints. We like this a lot on our teams because it keeps the report looking a lot simpler for those who don’t need all the extra detail.

One thing you may not have noticed is that I include checklists, customized for each position on the team. We have found checklists to be very helpful so we don’t miss any of the mundane stuff, especially when volunteers may only be serving once a month.

If you use my custom report file, all of the checklist code is already created for you. You just need to create the Plan Note fields to correspond with each position. Each position that has a checklist item should have a Plan Note Field like this:

Checklist – Team Name – Position Name

Any item in the list that begins with a “*” (asterisk) will be printed in a “DURING REHEARSAL” section, and only printed once. Any item that begins with a “~” (tilde) will be printed in an “AFTER EACH SERVICE” section for each service time and will include a small blank line for notes. Any other item will be printed in a “BEFORE SERVICE” section and will be printed once for each service time.

So, for example, a plan note in the field “Checklist – Tech Team – Stage Manager”:

*Take out trash

This would only print one time in the checklist, in the “During Rehearsal” section. You can edit the report to rename that header if you’d like.

~Shut all doors

This would print multiple times, once for each service time, in the “After Each Service” section.

Check for presentation

This would print multiple times, once for each service time, in the “Before Each Service” section. This is likely going to be the most-used field, so it is the one with the simplest formatting requirements.

I like to keep all of my checklists in a Template Plan (with no other items or people) within PCO, and just import them each week to the plan before printing. This allows me to update the checklists from time to time without hardcoding it into the report file, and I can customize it per-plan if needed.

I hope this is helpful to you! You can download all of my custom reports here: https://github.com/josephdadams/PlanningCenterServicesReports/

Elgato Stream Deck as Production Controller

A few months ago, I picked up this nifty device called a Stream Deck made by Elgato Gaming. It’s a 15-button USB keyboard with LCD buttons. It’s primarily marketed towards gamers who live stream so they can have quick access to commands and functions as they stream. The programmer in me couldn’t resist trying it out to help us with our production setup.

elgato-strream-deck-boxshot-tecs
The Stream Deck sells for about $140.

Using the base software provided, I was able to fairly quickly implement a workflow to allow volunteers to have easy access to buttons that then fire commands on our Ross Dashboard Production Control ecosystem. If you’ve not used Dashboard before, you can read about how we use it at my church here. It’s fairly easy to set up a custom panel in Dashboard that runs an HTTP web server at a specific port, which in turns allow you to “click” a button on the panel by calling that button’s trigger ID remotely via a specific URL.

Using the “URL” method provided in the base software, we are able to make web calls to the Dashboard custom panels to fire the commands. All the logic/code remains in Dashboard, and this just becomes a method of executing those commands remotely via an HTTP request.

Screen Shot 2018-05-01 at 8.16.41 PM
Here is a screenshot of the base software provided by Elgato. It’s very functional as is.

We used the base software for a few months without issue, however quickly realized the limitation of not being able to have bi-directional communication between our Dashboard Production Control and the individual Stream Decks. For example, several of our commands act as “toggles”, meaning we can have a few different state options that represent the current status of a device. If I only had one person making changes or operating the system, it wouldn’t be a huge issue. That person would hopefully remember what button they pressed last. However, when there are a lot of moving parts and multiple people controlling systems, the ability to update status on all devices becomes very helpful.

Enter NodeJS. People smarter than me took the time to write a base NodeJS library to control the Stream Deck. I hadn’t written in NodeJS before, but being a programmer, I was ready to learn something new. I downloaded and installed all the necessary libraries, IDE, etc. and quickly whipped up some code using the base library to control our stream decks. In just a few hours, I had something operational and started running it from the command line. I then spent a couple of weeks refining it and now we have a fully functional, self contained app that can run on Mac, Windows or Linux. It’s packaged using the Electron libraries made freely available with the Node platform.

1024x1024
This was the quick icon I whipped up for the software.

My controller software uses a base JSON file which defines the button structure of the stream deck. This makes it very flexible and expandable as our needs grow as I can just modify the JSON file to change the button structure.

Screen Shot 2018-05-01 at 8.25.25 PM
Here’s an example screenshot of one of my button files, written in JavaScript Object Notation. This allows me to add or remove buttons very easily and also programmatically.

The software then parses that JSON and builds the buttons on the Stream Deck in real time. If a button has a trigger action assigned, the command is sent to the corresponding device. I’ve written support for several protocols, including the Dashboard Web Call, RossTalk (good for sending messages to your Ross equipment), OSC, VideoHub routing, and more. You can even do internal stuff like jumping from one button page to another, changing button images during actions, etc. Each button can support an unlimited number of button actions, which I called triggers.

Screen Shot 2018-05-01 at 8.17.40 PM
The app runs completely in the tray with a simple context menu.

It also supports defining a set of devices, so if there’s a device you want to send messages to often, you can define the device in a separate file along with its host, port, type, etc. and then only refer to that device in the button structure. That way, if any of those related variables change,  you only have to change it in one place.

The software also runs a basic TCP listener server on a specific port, and this is where the bi-directional communication comes into play. Anytime a command is run on the master Dashboard Custom Panel Production Control, it relays a message to the remote Stream Deck via the TCP listener and updates the state of the button.

screen-shot-2018-05-01-at-8-18-05-pm.png
The settings menu allows you to choose the button/device files you want to use as well as whether the TCP listener service and notifications are turned on.
Screen Shot 2018-05-01 at 8.18.13 PM
A sample notification that can appear when a button is pressed. You can determine which triggers sent notifications.

This means that we can run commands from any originating location, whether it is the web-based production control (that I’m still developing), one of the remote Dashboard panels that connects to Production Control, one of the Stream Decks (we currently have 2 of them, one in each control room), or even the Master Control panel and every device will receive an updated status.

I also added a “Virtual Deck” option, which allows you to operate the software with or without having a physical Stream Deck attached. You can also choose to have the Virtual Deck operate independently of your physical Stream Deck, so it’s like having two decks in one!

Screen Shot 2018-05-01 at 8.17.26 PM
Here is a screenshot of the Virtual Deck in action.
Screen Shot 2018-05-01 at 8.18.26 PM
Here is what some buttons that have been toggled look like on the Virtual Deck. It’s very clear to see the current state of those buttons!

I am making this software freely available to anyone who can benefit from it. My hope is that the local church can make use of this to allow their volunteers to more easily operate tech equipment during services.

It’s currently up on GitHub here: https://github.com/josephdadams/StreamDeckProductionController

I’ve only built a Mac binary, but you can easily package it for Windows or Linux if needed.

I am working on an Editor function right now that will allow you to add/edit buttons without having to write them in JSON, but until then, you’ll have to make do with that option. Here’s a good tutorial on learning JSON if you need help: https://www.codecademy.com/courses/javascript-beginner-en-xTAfX/0/1

If I can help you out along the way, don’t hesitate to reach out!