index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Blue Jay | Go Toolkit for the Web</title>
    <link>https://blue-jay.github.io/</link>
    <description>Recent content on Blue Jay | Go Toolkit for the Web</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <atom:link href="https://blue-jay.github.io/index.xml" rel="self" type="application/rss+xml" />
    
    <item>
      <title>Blue Jay Overview</title>
      <link>https://blue-jay.github.io/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/</guid>
      <description>

&lt;p&gt;Blue Jay is a web toolkit for &lt;a href=&#34;https://golang.org/&#34;&gt;Go&lt;/a&gt;. It&amp;rsquo;s a collection of command-line tools and a web blueprint that allows you to easily structure your web application. There is no rigid framework to which you have to conform and the tools are easy to start using.&lt;/p&gt;

&lt;p&gt;There are a few components:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint&#34;&gt;&lt;strong&gt;Blueprint&lt;/strong&gt;&lt;/a&gt; is a model-view-controller (MVC) style web skeleton.&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/blue-jay/jay&#34;&gt;&lt;strong&gt;Jay&lt;/strong&gt;&lt;/a&gt; is a command line tool with find/replace, database migrations, and code generation.&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/blue-jay/core&#34;&gt;&lt;strong&gt;Core&lt;/strong&gt;&lt;/a&gt; is a collection of packages used
by Blueprint and Jay that can also be used by other projects.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;high-level&#34;&gt;High Level&lt;/h2&gt;

&lt;p&gt;Blueprint is a web application with a built-in web server and MySQL integration.
The application has a public home page, authenticated home page, login page,
register page, about page, and a simple notepad to demonstrate GET, POST,
PATCH, and DELETE operations.&lt;/p&gt;

&lt;p&gt;The entrypoint for the web app is &lt;strong&gt;blueprint.go&lt;/strong&gt; which uses the &lt;strong&gt;boot&lt;/strong&gt;
package to load the application settings, create the session store,
connect to the database, set up the views, load the routes, attach the
middleware, and then start the web server.&lt;/p&gt;

&lt;p&gt;The front end is built using &lt;a href=&#34;http://getbootstrap.com/&#34;&gt;Bootstrap&lt;/a&gt; with a few
small changes to fonts and
spacing. The flash messages are customized so they show up at the bottom right
corner of the screen. All of the error and warning messages should display to
the user or in the console. Informational messages are displayed to the user
via flash messages that disappear after 4 seconds.&lt;/p&gt;

&lt;p&gt;Blueprint also works well with &lt;a href=&#34;https://www.npmjs.com/&#34;&gt;npm&lt;/a&gt; and
&lt;a href=&#34;http://gulpjs.com/&#34;&gt;Gulp&lt;/a&gt;. A Gulp script is
included that automates the compiling of SASS, concatenation of JavaScript,
generation of favicons, and copying of static assets like Bootstrap and jQuery
(which are managed by npm) to the &lt;strong&gt;asset/static&lt;/strong&gt; folder.&lt;/p&gt;

&lt;p&gt;Jay is a command-line tool that pairs nicely with Blueprint. It has find/replace
functionality to make code refactoring is a little easier. It performs database
migration to easily update your database when sharing code
between teams. Jay provides template-based code generation that allows you to
build files like controllers, models, middleware, or even multiple views.
All templates (*.gen files) are parsed using
the &lt;strong&gt;text/template&lt;/strong&gt; package from the Go standard library and all generation
instructions (*.json files) allow you to specify which variables to pass via
&lt;strong&gt;Jay&lt;/strong&gt; as well as in which folder to create the templates. You can also build
collections of templates to generate more than one file set which is great when
you want to scaffold out a component with CRUD (create, read, update, and delete).&lt;/p&gt;

&lt;h2 id=&#34;quick-start-website-with-jay&#34;&gt;Quick Start Website with Jay&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;To download Blueprint, run the following command: &lt;code&gt;go get github.com/blue-jay/blueprint&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;To download Jay, run the following command: &lt;code&gt;go get github.com/blue-jay/jay&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;In your terminal, CD to the &lt;strong&gt;blueprint&lt;/strong&gt; folder.&lt;/li&gt;
&lt;li&gt;Run this command to create the env.json file from env.json.example: &lt;code&gt;jay env make&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Set the environment variable, JAYCONFIG, to the env.json file path. For example:

&lt;ul&gt;
&lt;li&gt;On Windows: &lt;code&gt;SET JAYCONFIG=C:\bluejay\workspace\src\github.com\blue-jay\blueprint\env.json&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;On Linux/OS X: &lt;code&gt;export JAYCONFIG=$HOME/workspace/src/github.com/blue-jay/blueprint/env.json&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;Start a MySQL instance.&lt;/li&gt;
&lt;li&gt;Edit the &lt;strong&gt;MySQL&lt;/strong&gt; section of env.json to match your database login information.&lt;/li&gt;
&lt;li&gt;Create the database and tables using the command: &lt;code&gt;jay migrate:mysql all&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Run the application: &lt;code&gt;go run blueprint.go&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Open your web browser to &lt;a href=&#34;http://localhost&#34;&gt;http://localhost&lt;/a&gt; and you should see the welcome page.&lt;/li&gt;
&lt;li&gt;Navigate to the register page at &lt;a href=&#34;http://localhost/register&#34;&gt;http://localhost/register&lt;/a&gt; and create a new user.&lt;/li&gt;
&lt;li&gt;You can now login at &lt;a href=&#34;http://localhost/login&#34;&gt;http://localhost/login&lt;/a&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;h3 id=&#34;os-specific-instructions&#34;&gt;OS Specific Instructions&lt;/h3&gt;

&lt;p&gt;There are also more detailed guides available by operating system:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/wiki/Blueprint-Setup-for-Amazon-AMI&#34;&gt;Setup for Amazon AMI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/wiki/Blueprint-Setup-for-Ubuntu-AMI&#34;&gt;Setup for Ubuntu AMI&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/wiki/Blueprint-Setup-for-OS-X&#34;&gt;Setup for OS X&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/wiki/Blueprint-Setup-for-Windows&#34;&gt;Setup for Windows&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;quick-start-website-without-jay&#34;&gt;Quick Start Website without Jay&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;To download Blueprint, run the following command: &lt;code&gt;go get github.com/blue-jay/blueprint&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Start a MySQL instance.&lt;/li&gt;
&lt;li&gt;Make a copy of env.json.example and name it: &lt;strong&gt;env.json&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Edit the &lt;strong&gt;MySQL&lt;/strong&gt; section in &lt;strong&gt;env.json&lt;/strong&gt; so the connection information matches your MySQL instance.&lt;/li&gt;
&lt;li&gt;In the &lt;strong&gt;Session&lt;/strong&gt; section, you should generate new passwords for the following keys:

&lt;ul&gt;
&lt;li&gt;AuthKey should be a 64 byte password and then base64 encoded&lt;/li&gt;
&lt;li&gt;EncryptKey should be a 32 byte password and then base64 encoded&lt;/li&gt;
&lt;li&gt;CSRFKey should be a 32 byte password and then base64 encoded&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;Create a database called &lt;strong&gt;blueprint&lt;/strong&gt; in MySQL.&lt;/li&gt;
&lt;li&gt;Import &lt;strong&gt;migration/mysql/20160630_020000.000000_init.up.sql&lt;/strong&gt; to create the tables.&lt;/li&gt;
&lt;li&gt;In your terminal, CD to the &lt;strong&gt;blueprint&lt;/strong&gt; folder.&lt;/li&gt;
&lt;li&gt;Run the application using the command: &lt;code&gt;go run blueprint.go&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Open your web browser to &lt;a href=&#34;http://localhost&#34;&gt;http://localhost&lt;/a&gt; and you should see the welcome page.&lt;/li&gt;
&lt;li&gt;Navigate to the register page at &lt;a href=&#34;http://localhost/register&#34;&gt;http://localhost/register&lt;/a&gt; and create a new user.&lt;/li&gt;
&lt;li&gt;You can now login at &lt;a href=&#34;http://localhost/login&#34;&gt;http://localhost/login&lt;/a&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&#34;why-blue-jay&#34;&gt;Why Blue Jay?&lt;/h2&gt;

&lt;p&gt;After 300 stars on GitHub, I realized people really liked the boilerplate
Model-View-Controller (MVC) web application in Go called
&lt;a href=&#34;https://github.com/josephspurrier/gowebapp&#34;&gt;gowebapp&lt;/a&gt; so I rewrote it with
better documentation.&lt;/p&gt;

&lt;p&gt;Go is a blast to code in and it&amp;rsquo;s great being part of a helpful community.
Blue Jay provides a quickstart for developers with a lean web skeleton called
&lt;strong&gt;Blueprint&lt;/strong&gt; that demonstrates how to structure a web application with sample
code.&lt;/p&gt;

&lt;p&gt;One of the things you&amp;rsquo;ll notice while using Blueprint is how to abstract out
external packages to make it easy to swap out components. Ultimately, you should
be able to write code once and use it in all of your other projects. The &lt;strong&gt;lib&lt;/strong&gt;
folder is a great place for all these packages with very few dependencies.&lt;/p&gt;

&lt;p&gt;You&amp;rsquo;ll also notice certain packages need to be thread-safe when building web applications.
An example is the &lt;strong&gt;github.com/core/view&lt;/strong&gt; package which provides thread-safe template caching.&lt;/p&gt;

&lt;p&gt;The other reason for Blue Jay is the command-line tool, &lt;strong&gt;jay&lt;/strong&gt;, which provides an easy way
to find/replace in a project when refactoring, migrate your database forwards or backwards, and
generate a file or sets or files using the Go &lt;a href=&#34;https://golang.org/pkg/html/template/&#34;&gt;html/template&lt;/a&gt;
package. Code generation can help you build faster and more efficiently with less mistakes.&lt;/p&gt;

&lt;h2 id=&#34;why-go&#34;&gt;Why Go?&lt;/h2&gt;

&lt;p&gt;One of the big draws to Go is the rich standard library. The standard library includes a web server,
web-safe templating, and
many other tools necessary to build a web application. Any features missing from the standard library are
written by other Go developers who are happy to contribute to the thriving community.&lt;/p&gt;

&lt;p&gt;Go allows you to write code that compiles to the majority of the architectures we use today so all your
code is pretty much portable. Go excels when you want to write command line apps instead of just scripts,
but that&amp;rsquo;s not the only niche.
The designers of Go wanted to build a language that solved problems between the Google development teams.
It&amp;rsquo;s a modern language that allows you to easily multi-thread your applications. It&amp;rsquo;s a &amp;ldquo;get stuff done&amp;rdquo;
language.&lt;/p&gt;

&lt;h2 id=&#34;screenshots&#34;&gt;Screenshots&lt;/h2&gt;

&lt;h3 id=&#34;public-home&#34;&gt;Public Home&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/home_anon.png&#34; alt=&#34;Image of Public Home&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;about&#34;&gt;About&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/about.png&#34; alt=&#34;Image of About&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;register&#34;&gt;Register&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/register.png&#34; alt=&#34;Image of Register&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;login&#34;&gt;Login&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/login.png&#34; alt=&#34;Image of Login&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;authenticated-home&#34;&gt;Authenticated Home&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/home_auth.png&#34; alt=&#34;Image of Auth Home&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;view-all-notes&#34;&gt;View All Notes&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/notepad_index.png&#34; alt=&#34;Image of Notepad View&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;add-note&#34;&gt;Add Note&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/notepad_create.png&#34; alt=&#34;Image of Notepad Add&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;view-one-note&#34;&gt;View One Note&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/notepad_view.png&#34; alt=&#34;Image of Notepad Edit&#34; /&gt;&lt;/p&gt;

&lt;h3 id=&#34;edit-note&#34;&gt;Edit Note&lt;/h3&gt;

&lt;p&gt;&lt;img src=&#34;https://blue-jay.github.io/images/notepad_edit.png&#34; alt=&#34;Image of Notepad Edit&#34; /&gt;&lt;/p&gt;

&lt;h2 id=&#34;feedback&#34;&gt;Feedback&lt;/h2&gt;

&lt;p&gt;All feedback is welcome. Let me know if you have any suggestions, questions, or criticisms.
If something is not idiomatic to Go, please let me know know so we can make it better.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Structure</title>
      <link>https://blue-jay.github.io/structure/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/structure/</guid>
      <description>

&lt;p&gt;It helps to understand the folder structure so you know where each of the
components lives.&lt;/p&gt;

&lt;h2 id=&#34;blueprint-structure&#34;&gt;Blueprint Structure&lt;/h2&gt;

&lt;p&gt;The project is organized into the following folders:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;asset/
|----dynamic/    - private assets like SASS files, single JavaScript files, and logo.png for favicon generation
|----static/     - public assets like CSS, JavaScript, and favicon.ico for Android, Apple, etc
controller/      - packages with routes and application logic
filestorage/     - files uploaded from an HTML form
generate/          - template pairs (.gen and .json) for generating code using jay
lib/             - packages you&#39;ll build that are used by the application (recommended to build with minimum dependencies)
|----boot/       - package for registering services and setting up all the components
|----env/        - package that holds the structure for the application settings
|----flight/     - package with a context that can be used by controllers to access application settings
middleware/      - packages that return a http.Handler to wrap around routes for ACL, request logging, etc
migration/       - migration database files
|----mysql/      - MySQL files for migrating database up and down
model/             - packages with database queries and structs matching tables
view/            - HTML templates parsed using the Go html/template package
viewfunc/        - packages that return a template.FuncMap for use in views
viewmodify/      - packages that modify view prior to rendering to add varibles like CSRF token and auth level
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The following files exist at the project root:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;blueprint.go     - entrypoint for the application
env.json.example - application config template for variables
gulpfile.js      - Gulp configuration that compiles SASS, concatenates JavaScript, etc
package.json     - npm configuration that loads Gulp, Boostrap, Underscore.js, etc
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;blueprint-external-go-packages&#34;&gt;Blueprint External Go Packages&lt;/h2&gt;

&lt;p&gt;There are a few external packages used in Blueprint:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;github.com/gorilla/context              - registry for global request variables
github.com/gorilla/csrf                 - CSRF protection for gorilla sessions
github.com/gorilla/sessions             - cookie and filesystem sessions
github.com/go-sql-driver/mysql          - MySQL driver
github.com/husobee/vestigo              - HTTP router with wildcards
github.com/jmoiron/sqlx                 - MySQL general purpose extensions
github.com/justinas/alice               - middleware chaining
golang.org/x/crypto/bcrypt              - password hashing algorithm
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;jay-structure&#34;&gt;Jay Structure&lt;/h2&gt;

&lt;p&gt;The project is simply a command-line interface for packages in the Core library
&lt;a href=&#34;https://github.com/blue-jay/core&#34;&gt;https://github.com/blue-jay/core&lt;/a&gt;. The packages that Jay uses from the Core
library are:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;env/       - package that creates and updates the env.json config file
find/      - package that finds case-sensitive matched text in files
generate/  - package that generates code from template pairs
migrate/   - package that handles the database migrations
replace/   - package that replaces case-sensitive matched text in files
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The following file exists at the project root of Jay:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;jay.go     - entrypoint for the application
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;jay-external-go-packages&#34;&gt;Jay External Go Packages&lt;/h2&gt;

&lt;p&gt;There is only one external packages used in Jay (not including the Core
library):&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;gopkg.in/alecthomas/kingpin.v2    - command-line and flag parser
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;core-structure&#34;&gt;Core Structure&lt;/h2&gt;

&lt;p&gt;The Core project contains many packages that are all divided into individual
folders. Each is well documented so the
&lt;a href=&#34;https://godoc.org/github.com/blue-jay/core&#34;&gt;GoDoc&lt;/a&gt; page should provide enough
information on each one.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Configuration</title>
      <link>https://blue-jay.github.io/configuration/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/configuration/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;Throughout this documentation, keep in mind everything in Blueprint is configurable.
You are not using a framework so don&amp;rsquo;t be afraid to change code. You don&amp;rsquo;t need to
use any of the components included with Blueprint, but it does give you a nice foundation to
start from. If you want to use YAML instead of JSON, it&amp;rsquo;s recommended to create a wrapper
library in the &lt;strong&gt;lib&lt;/strong&gt; folder and then load your env.yaml file via the &lt;strong&gt;blueprint.go&lt;/strong&gt;
file.&lt;/p&gt;

&lt;h2 id=&#34;jay-command-env&#34;&gt;Jay Command: env&lt;/h2&gt;

&lt;p&gt;One of the first steps before using Blueprint is to create &lt;strong&gt;env.json&lt;/strong&gt;. You can make
a copy of &lt;strong&gt;env.json.example&lt;/strong&gt; and then name it &lt;strong&gt;env.json&lt;/strong&gt;, just be sure to
generate a new &lt;strong&gt;AuthKey&lt;/strong&gt;, &lt;strong&gt;EncryptKey&lt;/strong&gt;, and &lt;strong&gt;CSRFKey&lt;/strong&gt; in the &lt;strong&gt;Session&lt;/strong&gt; section.&lt;/p&gt;

&lt;p&gt;You can also use &lt;strong&gt;jay&lt;/strong&gt; to create the env.json file with new session keys.
Just CD to the &lt;strong&gt;blueprint&lt;/strong&gt; folder and then run: &lt;code&gt;jay env make&lt;/code&gt;&lt;/p&gt;

&lt;p&gt;Here are the commands you can use with &lt;code&gt;jay env&lt;/code&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;# Create a new env.json file from env.json.example with newly generated session keys
jay env make

# Show a new set of session keys that can be copied and pasted into env.json
jay env keyshow

# Generate a new set of session keys and automatically apply them to env.json
env env keyupdate
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The &lt;strong&gt;env.json&lt;/strong&gt; file is a good place to set variables for the application so
you don&amp;rsquo;t have to hardcode them. If you want to add any of your own settings,
you can add them to &lt;strong&gt;env.json&lt;/strong&gt; and update the &lt;strong&gt;Info&lt;/strong&gt; struct
in the &lt;strong&gt;lib/env&lt;/strong&gt; package. Here is an example &lt;strong&gt;env.json&lt;/strong&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
	&amp;quot;Asset&amp;quot;:{
		&amp;quot;Folder&amp;quot;:&amp;quot;asset&amp;quot;
	},
	&amp;quot;Email&amp;quot;:{
		&amp;quot;Username&amp;quot;:&amp;quot;&amp;quot;,
		&amp;quot;Password&amp;quot;:&amp;quot;&amp;quot;,
		&amp;quot;Hostname&amp;quot;:&amp;quot;&amp;quot;,
		&amp;quot;Port&amp;quot;:25,
		&amp;quot;From&amp;quot;:&amp;quot;&amp;quot;
	},
	&amp;quot;Form&amp;quot;:{
		&amp;quot;FileStorageFolder&amp;quot;:&amp;quot;filestorage&amp;quot;
	},
	&amp;quot;Generation&amp;quot;:{
		&amp;quot;TemplateFolder&amp;quot;:&amp;quot;generate&amp;quot;
	},
	&amp;quot;MySQL&amp;quot;:{
		&amp;quot;Username&amp;quot;:&amp;quot;root&amp;quot;,
		&amp;quot;Password&amp;quot;:&amp;quot;&amp;quot;,
		&amp;quot;Database&amp;quot;:&amp;quot;blueprint&amp;quot;,
		&amp;quot;Charset&amp;quot;:&amp;quot;utf8mb4&amp;quot;,
		&amp;quot;Collation&amp;quot;:&amp;quot;utf8mb4_unicode_ci&amp;quot;,
		&amp;quot;Hostname&amp;quot;:&amp;quot;127.0.0.1&amp;quot;,
		&amp;quot;Port&amp;quot;:3306,
		&amp;quot;Parameter&amp;quot;:&amp;quot;parseTime=true&amp;quot;,
		&amp;quot;Migration&amp;quot;:{
			&amp;quot;Folder&amp;quot;:&amp;quot;migration/mysql&amp;quot;,
			&amp;quot;Table&amp;quot;:&amp;quot;migration_blueprint&amp;quot;,
			&amp;quot;Extension&amp;quot;:&amp;quot;sql&amp;quot;
		}
	},
	&amp;quot;Server&amp;quot;:{
		&amp;quot;Hostname&amp;quot;:&amp;quot;&amp;quot;,
		&amp;quot;UseHTTP&amp;quot;:true,
		&amp;quot;UseHTTPS&amp;quot;:false,
		&amp;quot;RedirectToHTTPS&amp;quot;:false,
		&amp;quot;HTTPPort&amp;quot;:80,
		&amp;quot;HTTPSPort&amp;quot;:443,
		&amp;quot;CertFile&amp;quot;:&amp;quot;tls/server.crt&amp;quot;,
		&amp;quot;KeyFile&amp;quot;:&amp;quot;tls/server.key&amp;quot;
	},
	&amp;quot;Session&amp;quot;:{
		&amp;quot;AuthKey&amp;quot;:&amp;quot;PzCh6FNAB7/jhmlUQ0+25sjJ+WgcJeKR2bAOtnh9UnfVN+WJSBvY/YC80Rs+rbMtwfmSP4FUSxKPtpYKzKFqFA==&amp;quot;,
		&amp;quot;EncryptKey&amp;quot;:&amp;quot;3oTKCcKjDHMUlV+qur2Ve664SPpSuviyGQ/UqnroUD8=&amp;quot;,
		&amp;quot;CSRFKey&amp;quot;:&amp;quot;xULAGF5FcWvqHsXaovNFJYfgCt6pedRPROqNvsZjU18=&amp;quot;,
		&amp;quot;Name&amp;quot;:&amp;quot;sess&amp;quot;,
		&amp;quot;Options&amp;quot;:{
			&amp;quot;Path&amp;quot;:&amp;quot;/&amp;quot;,
			&amp;quot;Domain&amp;quot;:&amp;quot;&amp;quot;,
			&amp;quot;MaxAge&amp;quot;:28800,
			&amp;quot;Secure&amp;quot;:false,
			&amp;quot;HttpOnly&amp;quot;:true
		}
	},
	&amp;quot;Template&amp;quot;:{
		&amp;quot;Root&amp;quot;:&amp;quot;base&amp;quot;,
		&amp;quot;Children&amp;quot;:[
			&amp;quot;partial/favicon&amp;quot;,
			&amp;quot;partial/menu&amp;quot;,
			&amp;quot;partial/footer&amp;quot;
		]
	},
	&amp;quot;View&amp;quot;:{
		&amp;quot;BaseURI&amp;quot;:&amp;quot;/&amp;quot;,
		&amp;quot;Extension&amp;quot;:&amp;quot;tmpl&amp;quot;,
		&amp;quot;Folder&amp;quot;:&amp;quot;view&amp;quot;,
		&amp;quot;Caching&amp;quot;:true
	}
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;production&#34;&gt;Production&lt;/h2&gt;

&lt;p&gt;When you move your application to production, you should make the following
changes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Set &lt;strong&gt;Server&lt;/strong&gt;.&lt;strong&gt;Hostname&lt;/strong&gt; to the server&lt;/li&gt;
&lt;li&gt;Set &lt;strong&gt;Server&lt;/strong&gt;.&lt;strong&gt;UseHTTPS&lt;/strong&gt; to true&lt;/li&gt;
&lt;li&gt;Generate a certificate and key for HTTPS and place in the &lt;strong&gt;tls&lt;/strong&gt; folder&lt;/li&gt;
&lt;li&gt;Set &lt;strong&gt;Session&lt;/strong&gt;.&lt;strong&gt;Secure&lt;/strong&gt; to true&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;configuration-structure&#34;&gt;Configuration Structure&lt;/h2&gt;

&lt;p&gt;The &lt;strong&gt;env.json&lt;/strong&gt; file contains the configuration for Blueprint and Jay. It removes the need
to hardcode any of these values and makes it easy to move Blueprint to another system
with a different setup. The &lt;strong&gt;env.json&lt;/strong&gt; file is parsed to the
&lt;strong&gt;Info&lt;/strong&gt; struct from the &lt;strong&gt;lib/env&lt;/strong&gt; package:&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/lib/env/env.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Info contains the application settings.
type Info struct {
  Asset      asset.Info    `json:&amp;quot;Asset&amp;quot;`
  Email      email.Info    `json:&amp;quot;Email&amp;quot;`
  Form       form.Info     `json:&amp;quot;Form&amp;quot;`
  Generation generate.Info `json:&amp;quot;Generation&amp;quot;`
  MySQL      mysql.Info    `json:&amp;quot;MySQL&amp;quot;`
  Server     server.Info   `json:&amp;quot;Server&amp;quot;`
  Session    session.Info  `json:&amp;quot;Session&amp;quot;`
  Template   view.Template `json:&amp;quot;Template&amp;quot;`
  View       view.Info     `json:&amp;quot;View&amp;quot;`
  path       string
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The &lt;strong&gt;Info&lt;/strong&gt; struct is a container that nests structs from packages in
the &lt;strong&gt;Core&lt;/strong&gt; library that need variables configured. The &lt;strong&gt;Path&lt;/strong&gt; variable is
the location of the env.json file. Here is a list mapping the JSON keys to
structs:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;Asset     - Info struct in core/asset
Email     - Info struct in core/email
Form      - Info struct in core/form
Generate  - Info struct in core/generate
MySQL     - Info struct in core/mysql
Server    - Info struct in core/server
Session   - Info struct in core/session
Template  - Template struct in core/view
View      - Info struct in core/view
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;using-flight&#34;&gt;Using Flight&lt;/h2&gt;

&lt;p&gt;The &lt;strong&gt;flight&lt;/strong&gt; package provides access to the session variables, env.json settings,
database connections, views, and general shortcuts. It&amp;rsquo;s mostly designed for
controllers, but it can be used by other packages as well.&lt;/p&gt;

&lt;p&gt;To use package, you would call the &lt;strong&gt;flight.Context()&lt;/strong&gt; function like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Index displays the items.
func Index(w http.ResponseWriter, r *http.Request) {
	c := flight.Context(w, r)

	items, _, err := note.ByUserID(c.DB, c.UserID)
	if err != nil {
		c.FlashError(err)
		items = []note.Item{}
	}

	v := c.View.New(&amp;quot;note/index&amp;quot;)
	v.Vars[&amp;quot;items&amp;quot;] = items
	v.Render(w, r)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Flight needs a &lt;strong&gt;http.ResponseWriter&lt;/strong&gt; and a &lt;strong&gt;http.Request&lt;/strong&gt; so it can access
the sessions variables and provide shortcuts for the following tasks:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;reading URL parameters: c.Param(name string)&lt;/li&gt;
&lt;li&gt;redirecting to a page: c.Redirect(urlStr string)&lt;/li&gt;
&lt;li&gt;validation a form and sets a flash message: c.FormValid(fields &amp;hellip;string)&lt;/li&gt;
&lt;li&gt;repopulating a form: c.Repopulate(v map[string]interface{}, fields &amp;hellip;string)&lt;/li&gt;
&lt;li&gt;setting flash messages and then saving the session: c.FlashSuccess(message string)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Flight also provides access to the following:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;configuration settings from env.json: &lt;code&gt;c.Config.Asset.Folder&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;session: &lt;code&gt;c.Sess.Values[&amp;quot;email&amp;quot;]&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;current user ID: &lt;code&gt;c.UserID&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;view package: &lt;code&gt;c.View.New(&amp;quot;home/index&amp;quot;)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;database connection: &lt;code&gt;items, _, err := note.ByUserID(c.DB, c.UserID)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It is not a requirement to use the &lt;strong&gt;flight&lt;/strong&gt; package, but it makes working
with the different web components much easier. Feel free to modify the package
to fit your needs. Just make sure it is thread-safe.&lt;/p&gt;

&lt;h2 id=&#34;enable-https&#34;&gt;Enable HTTPS&lt;/h2&gt;

&lt;p&gt;To enable HTTPS:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Set &lt;strong&gt;UseHTTPS&lt;/strong&gt; to &lt;strong&gt;true&lt;/strong&gt; in the &lt;strong&gt;env.json&lt;/strong&gt; file&lt;/li&gt;
&lt;li&gt;Create a folder called &lt;strong&gt;tls&lt;/strong&gt; in the project root folder&lt;/li&gt;
&lt;li&gt;Place your own certificate and key files in the &lt;strong&gt;tls&lt;/strong&gt; folder&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;strong&gt;Note:&lt;/strong&gt; If you want to redirect HTTP to HTTPS, you can set &lt;strong&gt;RedirectToHTTPS&lt;/strong&gt; to &lt;strong&gt;true&lt;/strong&gt; in the &lt;strong&gt;env.json&lt;/strong&gt; file as well.&lt;/p&gt;

&lt;h2 id=&#34;tip-add-a-section&#34;&gt;Tip: Add a Section&lt;/h2&gt;

&lt;p&gt;To add a new key called &lt;strong&gt;Captcha&lt;/strong&gt;, your workflow would consist of the
following:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Create a new package in the &lt;strong&gt;lib&lt;/strong&gt; folder called &lt;strong&gt;captcha&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Create a struct called &lt;strong&gt;Info&lt;/strong&gt; in the &lt;strong&gt;lib/captcha&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;Add the struct to the &lt;strong&gt;Info&lt;/strong&gt; struct in the &lt;strong&gt;lib/env&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;Add the &lt;strong&gt;Captcha&lt;/strong&gt; key and any values to the &lt;strong&gt;env.json&lt;/strong&gt; file&lt;/li&gt;
&lt;li&gt;Add code to the &lt;strong&gt;RegisterServices()&lt;/strong&gt; function in the &lt;strong&gt;lib/boot&lt;/strong&gt; package to pass the any additional settings to the &lt;strong&gt;lib/flight&lt;/strong&gt; package at start up&lt;/li&gt;
&lt;li&gt;Add code to your controllers that references uses &lt;strong&gt;flight.Context()&lt;/strong&gt; to retrieve your &lt;strong&gt;lib/captcha&lt;/strong&gt; package settings&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&#34;tip-remove-a-section&#34;&gt;Tip: Remove a Section&lt;/h2&gt;

&lt;p&gt;To remove the &lt;strong&gt;Email&lt;/strong&gt; key, your workflow would consist of the following:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Remove the &lt;strong&gt;Email&lt;/strong&gt; key and value from the &lt;strong&gt;env.json&lt;/strong&gt; file&lt;/li&gt;
&lt;li&gt;Remove the &lt;strong&gt;Email&lt;/strong&gt; nested struct from the &lt;strong&gt;Info&lt;/strong&gt; struct in the &lt;strong&gt;lib/env&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;Remove any code setting up the package from the &lt;strong&gt;RegisterServices()&lt;/strong&gt; function in the &lt;strong&gt;boot&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;Remove the &lt;strong&gt;lib/email&lt;/strong&gt; package from the filesystem&lt;/li&gt;
&lt;li&gt;Find any references to the &lt;strong&gt;lib/email&lt;/strong&gt; package in your code using the jay command line, &lt;code&gt;jay find . &amp;quot;lib/email&amp;quot;&lt;/code&gt;,
then delete the imports and referencing code&lt;/li&gt;
&lt;/ol&gt;
</description>
    </item>
    
    <item>
      <title>Assets</title>
      <link>https://blue-jay.github.io/assets/</link>
      <pubDate>Thu, 30 Jun 2016 21:07:13 +0100</pubDate>
      
      <guid>https://blue-jay.github.io/assets/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;Out of the box, all of the static assets like CSS and JavaScript are ready to
demo. If you want to make changes to the file, it&amp;rsquo;s best to use the tools
provided. The &lt;strong&gt;asset&lt;/strong&gt; folder contains a &lt;strong&gt;dynamic&lt;/strong&gt; folder and a &lt;strong&gt;static&lt;/strong&gt;
folder.&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;dynamic&lt;/strong&gt; folder contains the Syntactically Awesome Style Sheets (SASS),
individual JavaScript files, and a large PNG image which is used to generate
favicons for different platforms like Android, iPhone, etc. &lt;em&gt;This is the folder
in which you want to make your changes.&lt;/em&gt; The dynamic folder holds some of the
assets required to generate the assets in the &lt;strong&gt;static&lt;/strong&gt; folder.&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;static&lt;/strong&gt; folder contains the minified CSS and JavaScript as well as
the generated favicons. The &lt;strong&gt;static&lt;/strong&gt; folder is designed to be served up
so the files can be accessed like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;!-- Favicons --&amp;gt;
&amp;lt;link rel=&amp;quot;apple-touch-icon&amp;quot; sizes=&amp;quot;57x57&amp;quot; href=&amp;quot;/static/favicon/apple-touch-icon-57x57.png?v1.0=3eepn6WlLO&amp;quot;&amp;gt;
&amp;lt;link rel=&amp;quot;apple-touch-icon&amp;quot; sizes=&amp;quot;60x60&amp;quot; href=&amp;quot;/static/favicon/apple-touch-icon-60x60.png?v1.0=3eepn6WlLO&amp;quot;&amp;gt;
&amp;lt;link rel=&amp;quot;apple-touch-icon&amp;quot; sizes=&amp;quot;72x72&amp;quot; href=&amp;quot;/static/favicon/apple-touch-icon-72x72.png?v1.0=3eepn6WlLO&amp;quot;&amp;gt;
&amp;lt;!-- CSS and Fonts --&amp;gt;
&amp;lt;link media=&amp;quot;all&amp;quot; rel=&amp;quot;stylesheet&amp;quot; type=&amp;quot;text/css&amp;quot; href=&amp;quot;/static/css/bootstrap.min.css?1466973904&amp;quot; /&amp;gt;
&amp;lt;link media=&amp;quot;all&amp;quot; rel=&amp;quot;stylesheet&amp;quot; type=&amp;quot;text/css&amp;quot; href=&amp;quot;//fonts.googleapis.com/css?family=Open+Sans:300,400,bold,italic&amp;quot; /&amp;gt;
&amp;lt;link media=&amp;quot;all&amp;quot; rel=&amp;quot;stylesheet&amp;quot; type=&amp;quot;text/css&amp;quot; href=&amp;quot;/static/css/all.css?1466973904&amp;quot; /&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Check out the &lt;a href=&#34;https://blue-jay.github.io/controllers&#34;&gt;Controllers&lt;/a&gt; and
&lt;a href=&#34;https://blue-jay.github.io/views/#included-functions&#34;&gt;Views&lt;/a&gt; pages for how
the files are served and how timestamps are append to them for cach management.&lt;/p&gt;

&lt;p&gt;If you make changes to any of the files in the &lt;strong&gt;dynamic&lt;/strong&gt; folder, you still
need a way to compile/minify them and then move them to the &lt;strong&gt;static&lt;/strong&gt; folder
so we&amp;rsquo;ll use Gulp to do that.&lt;/p&gt;

&lt;h2 id=&#34;install-npm&#34;&gt;Install npm&lt;/h2&gt;

&lt;p&gt;The Node Package Manager (npm) helps install packages that work with NodeJS.
If you don&amp;rsquo;t have NodeJS and npm installed, you can install the latest version
from &lt;a href=&#34;https://nodejs.org&#34;&gt;https://nodejs.org&lt;/a&gt;.&lt;/p&gt;

&lt;h2 id=&#34;install-gulp-and-dependencies&#34;&gt;Install Gulp and Dependencies&lt;/h2&gt;

&lt;p&gt;Once npm is installed, you can open your terminal and CD to the root of the
project folder. You can then run these commands:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;# Install Gulp globally
npm install -g gulp-cli

# Install Gulp locally and dependencies from package.json
npm install
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;gulp&#34;&gt;Gulp&lt;/h2&gt;

&lt;p&gt;Once the environment is set up, you should have your terminal open to the root
of the project folder. There are a couple commands you can use with Gulp that
are in the &lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/gulpfile.js&#34;&gt;gulpfile.js&lt;/a&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;# Compile the SASS from asset/dynamic/sass and store CSS in asset/static/css/all.css
gulp sass

# Concat the JavaScript from asset/dynamic/js and store JS in asset/static/js/all.js
gulp javascript

# Copy the jQuery files from node_modules/jquery to asset/static/js
gulp jquery

# Copy the Bootstrap files from node_modules/bootstrap to asset/static
gulp bootstrap

# Copy the Underscore files from note_modules/underscore to asset/static/js
gulp underscore

# Run tasks favicon-generate and favicon-inject
gulp favicon

# Generate favicons from asset/dynamic/logo.png and copy to /asset/static/favicon
gulp favicon-generate

# Generate view/partial/favicon.tmpl with favicon tags
gulp favicon-inject

# Update the asset/dynamic/favicon/data.json file with the latest version from the RealFaviconGenerator website
gulp favicon-update

# Run the sass and javascript tasks when any of the files change
gulp watch

# Run all the tasks once
gulp init

# Run just the sass and javascript tasks once
gulp default
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;It is best to run &lt;code&gt;gulp watch&lt;/code&gt; so when you are working with the SASS and
JavaScript files so they will automatically generate in the &lt;strong&gt;static&lt;/strong&gt; folder
for you.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Routing</title>
      <link>https://blue-jay.github.io/routing/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/routing/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;When a user requests a page from your application, the routes determine which
page is shown. The route is a URL that is mapped to a controller function.
To simplify the organization, the routes are stored in the controller files.
The controller files are all organized under the &lt;strong&gt;controller&lt;/strong&gt; folder.&lt;/p&gt;

&lt;h2 id=&#34;routing&#34;&gt;Routing&lt;/h2&gt;

&lt;p&gt;In the &lt;strong&gt;boot&lt;/strong&gt; package, the &lt;strong&gt;RegisterServices()&lt;/strong&gt; function
calls the &lt;strong&gt;controller.LoadRoutes()&lt;/strong&gt; function. The &lt;strong&gt;LoadRoutes()&lt;/strong&gt; function in
 the &lt;strong&gt;controller&lt;/strong&gt; package loads the routes for each of the individual
 controllers:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// LoadRoutes loads the routes for each of the controllers.
func LoadRoutes() {
    about.Load()
    debug.Load()
    register.Load()
    login.Load()
    home.Load()
    static.Load()
    status.Load()
    notepad.Load()
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Here is the &lt;strong&gt;Load()&lt;/strong&gt; function from the &lt;strong&gt;controller/notepad&lt;/strong&gt; package:&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/controller/static/static.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package static serves static files like CSS, JavaScript, and images.
package static

import (
    &amp;quot;net/http&amp;quot;
    &amp;quot;os&amp;quot;
    &amp;quot;path&amp;quot;

    &amp;quot;github.com/blue-jay/blueprint/controller/status&amp;quot;
    &amp;quot;github.com/blue-jay/blueprint/lib/flight&amp;quot;

    &amp;quot;github.com/blue-jay/core/router&amp;quot;
)

// Load the routes.
func Load() {
    // Serve static files
    router.Get(&amp;quot;/static/*filepath&amp;quot;, Index)
}

// Index maps static files.
func Index(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    // File path
    path := path.Join(c.Config.Asset.Folder, r.URL.Path[1:])

    // Only serve files
    if fi, err := os.Stat(path); err == nil &amp;amp;&amp;amp; !fi.IsDir() {
        http.ServeFile(w, r, path)
        return
    }

    status.Error404(w, r)
}

&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;error-pages&#34;&gt;Error Pages&lt;/h2&gt;

&lt;p&gt;A few errors pages are already defined for you like the &lt;strong&gt;404&lt;/strong&gt; (Page Not Found)
and &lt;strong&gt;405&lt;/strong&gt; (Method Not Allowed) pages.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/controller/status/status.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package status provides all the error pages like 404, 405, 500, 501,
// and the page when a CSRF token is invalid.
package status

import (
    &amp;quot;net/http&amp;quot;

    &amp;quot;github.com/blue-jay/blueprint/lib/flight&amp;quot;
    &amp;quot;github.com/blue-jay/core/router&amp;quot;
)

// Load the routes.
func Load() {
    router.MethodNotAllowed(Error405)
    router.NotFound(Error404)
}

// Error404 - Page Not Found.
func Error404(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)
    w.WriteHeader(http.StatusNotFound)
    v := c.View.New(&amp;quot;status/index&amp;quot;)
    v.Vars[&amp;quot;title&amp;quot;] = &amp;quot;404 Not Found&amp;quot;
    v.Vars[&amp;quot;message&amp;quot;] = &amp;quot;Page could not be found.&amp;quot;
    v.Render(w, r)
}

// Error405 - Method Not Allowed.
func Error405(allowedMethods string) func(w http.ResponseWriter, r *http.Request) {
    return func(w http.ResponseWriter, r *http.Request) {
        c := flight.Context(w, r)
        w.WriteHeader(http.StatusMethodNotAllowed)
        v := c.View.New(&amp;quot;status/index&amp;quot;)
        v.Vars[&amp;quot;title&amp;quot;] = &amp;quot;405 Method Not Allowed&amp;quot;
        v.Vars[&amp;quot;message&amp;quot;] = &amp;quot;Method is not allowed.&amp;quot;
        v.Render(w, r)
    }
}
...
&lt;/code&gt;&lt;/pre&gt;
</description>
    </item>
    
    <item>
      <title>Middleware</title>
      <link>https://blue-jay.github.io/middleware/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/middleware/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;Middleware, in the context of Go, is applied during routing to provide
features like request/response logging, access controls lists (ACLs), and
header modification. Middleware is either applied to every request (like for
request logging) or specified routes (like for ACLs).&lt;/p&gt;

&lt;p&gt;There are a few pieces of middleware included. The package called &lt;strong&gt;csrf&lt;/strong&gt;
protects against Cross-Site Request Forgery attacks.
The &lt;strong&gt;logrequest&lt;/strong&gt; package will log every request made against the
website to the console. The &lt;strong&gt;rest&lt;/strong&gt; package allows the HTTP method to be
changed during a form submission to DELETE or PATCH instead of POST.&lt;/p&gt;

&lt;h2 id=&#34;creating-middleware&#34;&gt;Creating Middleware&lt;/h2&gt;

&lt;p&gt;An example of a piece of middleware that is applied to every request is
&lt;strong&gt;middleware/logrequest&lt;/strong&gt;. When a page is requested, the middleware will
print to the console: the time of the request, remote IP address, HTTP method,
and the URL requested.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/middleware/logrequest/logrequest.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package logrequest provides an http.Handler that logs when a request is
// made to the application and lists the remote address, the HTTP method,
// and the URL.
package logrequest

import (
    &amp;quot;fmt&amp;quot;
    &amp;quot;net/http&amp;quot;
    &amp;quot;time&amp;quot;
)

// Handler will log the HTTP requests.
func Handler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println(time.Now().Format(&amp;quot;2006-01-02 03:04:05 PM&amp;quot;), r.RemoteAddr, r.Method, r.URL)
        next.ServeHTTP(w, r)
    })
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;This is an example of the minimum code required for middleware:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Handler
func Handler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Logic BEFORE the other handlers and function goes here
        next.ServeHTTP(w, r)
        // Logic AFTER the other handlers and function goes here
    })
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;chaining&#34;&gt;Chaining&lt;/h2&gt;

&lt;p&gt;The more middleware you use, the more it stacks up like this and makes it hard
to read:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;return context.ClearHandler(rest.Handler(logrequest.Handler(setUpCSRF)))
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Before &lt;a href=&#34;https://github.com/justinas/alice&#34;&gt;justinas/alice&lt;/a&gt;, a workaround was to
use a variable and reassign it multiple times like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;h = setUpCSRF(h)
h = logrequest.Handler(h)
h = rest.Handler(h)
return context.ClearHandler(h)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;You can see chaining in action in &lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/controller/notepad/notepad.go&#34;&gt;controller/notepad&lt;/a&gt;
where the controller uses the &lt;strong&gt;router.ChainHandler()&lt;/strong&gt; function.
The function is a wrapper for
the &lt;a href=&#34;https://github.com/justinas/alice&#34;&gt;justinas/alice&lt;/a&gt; package which makes
using middleware more scalable and a little &amp;ldquo;prettier&amp;rdquo;. If you look at the
&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/lib/boot/middleware.go&#34;&gt;lib/boot&lt;/a&gt;
package, you&amp;rsquo;ll see the &lt;strong&gt;ChainHandler()&lt;/strong&gt; function. There is also a &lt;strong&gt;Chain()&lt;/strong&gt;
function that can be used to chain middleware for routes or to pass to
&lt;strong&gt;ChainHandler()&lt;/strong&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Apply middleware to routes individually
router.Get(&amp;quot;/notepad&amp;quot;, Index, acl.DisallowAnon, logrequest.Handler)
router.Get(&amp;quot;/notepad/create&amp;quot;, Create, acl.DisallowAnon, logrequest.Handler)

// Use Chain() to apply middleware
c := router.Chain(acl.DisallowAnon, logrequest.Handler)
router.Get(&amp;quot;/notepad&amp;quot;, Index, c...)
router.Get(&amp;quot;/notepad/create&amp;quot;, Create, c...)

// Pass Chain() to ChainHandler()
c := router.Chain( // Chain middleware, bottom runs first
    h,                    // Handler to wrap
    setUpCSRF,            // Prevent CSRF
    rest.Handler,         // Support changing HTTP method sent via query string
    logrequest.Handler,   // Log every request
    context.ClearHandler, // Prevent memory leak with gorilla.sessions
)
return router.ChainHandler(c...)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;&lt;strong&gt;ChainHandler()&lt;/strong&gt; accepts one or more of the http.Handler type and returns a
http.Handler.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Chain()&lt;/strong&gt; accepts one or more of the http.Handler type and returns an array of
the alice.Constructor type.&lt;/p&gt;

&lt;h2 id=&#34;apply-to-every-request&#34;&gt;Apply to Every Request&lt;/h2&gt;

&lt;p&gt;In &lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/blueprint.go&#34;&gt;blueprint.go&lt;/a&gt;,
the application calls &lt;strong&gt;boot.SetUpMiddleware(router.Instance())&lt;/strong&gt; which
applies the middleware to the router. The middleware is called on every
request.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/lib/boot/middleware.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// SetUpMiddleware contains the middleware that applies to every request.
func SetUpMiddleware(h http.Handler) http.Handler {
    return router.ChainHandler( // Chain middleware, top middlware runs first
        h,                    // Handler to wrap
        setUpCSRF,            // Prevent CSRF
        rest.Handler,         // Support changing HTTP method sent via query string
        logrequest.Handler,   // Log every request
        context.ClearHandler, // Prevent memory leak with gorilla.sessions
    )
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;apply-to-specific-routes&#34;&gt;Apply to Specific Routes&lt;/h2&gt;

&lt;p&gt;In &lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/controller/notepad/notepad.go&#34;&gt;controller/notepad&lt;/a&gt;,
the application creates a chain of middleware and then
applies it to only certain routes. In this scenario, the pages are only
accessible if the user is authenticated.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/controller/notepad/notepad.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;func Load() {
    // Add middleware that disallows anonymous access
    c := router.Chain(acl.DisallowAnon)

    // Map HTTP methods and URLs to functions wrapped in the middleware chain
    router.Get(&amp;quot;/notepad&amp;quot;, Index, c...)
    router.Get(&amp;quot;/notepad/create&amp;quot;, Create, c...)
    router.Post(&amp;quot;/notepad&amp;quot;, Store, c...)
    router.Get(&amp;quot;/notepad/view/:id&amp;quot;, Show, c...)
    router.Get(&amp;quot;/notepad/edit/:id&amp;quot;, Edit, c...)
    router.Patch(&amp;quot;/notepad/edit/:id&amp;quot;, Update, c...)
    router.Delete(&amp;quot;/notepad/:id&amp;quot;, Destroy, c...)
}
&lt;/code&gt;&lt;/pre&gt;
</description>
    </item>
    
    <item>
      <title>Controllers</title>
      <link>https://blue-jay.github.io/controllers/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/controllers/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;The controller files are all organized under the &lt;strong&gt;controller&lt;/strong&gt; folder. The
controllers handle the interactions between the models and the views as well as
specify which routes to map to which functions.&lt;/p&gt;

&lt;p&gt;It&amp;rsquo;s a good idea to follow a naming convention for the different pieces.
Laravel developers will notice it&amp;rsquo;s very similar, but with a few changes.&lt;/p&gt;

&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th align=&#34;center&#34;&gt;Method&lt;/th&gt;
&lt;th align=&#34;center&#34;&gt;Path&lt;/th&gt;
&lt;th align=&#34;center&#34;&gt;Function&lt;/th&gt;
&lt;th align=&#34;center&#34;&gt;View&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;

&lt;tbody&gt;
&lt;tr&gt;
&lt;td align=&#34;center&#34;&gt;GET&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;/notepad&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;Index&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;index.tmpl&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;center&#34;&gt;GET&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;/notepad/create&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;Create&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;create.tmpl&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;center&#34;&gt;POST&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;/notepad/create&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;Store&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;center&#34;&gt;GET&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;/notepad/view/:id&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;Show&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;show.tmpl&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;center&#34;&gt;GET&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;/notepad/edit/:id&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;Edit&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;edit.tmpl&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;center&#34;&gt;PATCH&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;/notepad/edit/:id&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;Update&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;&lt;/td&gt;
&lt;/tr&gt;

&lt;tr&gt;
&lt;td align=&#34;center&#34;&gt;DELETE&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;/notepad/:id&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;Destroy&lt;/td&gt;
&lt;td align=&#34;center&#34;&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;

&lt;p&gt;Here is a controller that follows the naming convention. Notice
the model name (&lt;strong&gt;note&lt;/strong&gt;) matches the view folder (&lt;strong&gt;note/index&lt;/strong&gt;). The model does
not need to match the controller because you&amp;rsquo;ll be working with many different
models in your controllers.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;func Load() {
	...
	// &amp;quot;Get&amp;quot; is the Method
	// &amp;quot;/notepad&amp;quot; is the Path
	router.Get(&amp;quot;/notepad&amp;quot;, Index, acl.DisallowAnon)
	...
}

// Index displays the items.
func Index(w http.ResponseWriter, r *http.Request) {
	c := flight.Context(w, r)

	items, _, err := note.ByUserID(c.DB, c.UserID)
	if err != nil {
		c.FlashError(err)
		items = []note.Item{}
	}

	v := c.View.New(&amp;quot;note/index&amp;quot;)
	v.Vars[&amp;quot;items&amp;quot;] = items
	v.Render(w, r)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;access-a-session&#34;&gt;Access a Session&lt;/h2&gt;

&lt;p&gt;Sessions provide access to flash messages as well as variables that are set at
login. You &lt;strong&gt;must&lt;/strong&gt; remember to save the sessions once you make a change to
them.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Get the current session
sess, _ := session.Instance(r)
...
// Save the session after you are finished making changes
sess.Save(r, w)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;trigger-flash-message&#34;&gt;Trigger Flash Message&lt;/h2&gt;

&lt;p&gt;Flash messages will appear to the user on next page load. They only display
once. The built-in messages are tied to Bootstrap classes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;flash.Success is green (alert-success)&lt;/li&gt;
&lt;li&gt;flash.Warning is yellow (alert-warning)&lt;/li&gt;
&lt;li&gt;flash.Notice is blue (alert-info)&lt;/li&gt;
&lt;li&gt;flash.Error is red (alert-danger)&lt;/li&gt;
&lt;/ul&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;sess.AddFlash(flash.Info{&amp;quot;Welcome to Blueprint!&amp;quot;, flash.Success})
sess.Save(r, w) // Ensure you save the session after making a change to it
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;validate-a-form&#34;&gt;Validate a Form&lt;/h2&gt;

&lt;p&gt;The &lt;strong&gt;form&lt;/strong&gt; package makes it easy to validate required fields. It works on the
inputs: text, textarea, checkbox, radio, and select. The function,
&lt;strong&gt;form.Required()&lt;/strong&gt;, requires the request and then any number of fields
as it is a variadic function. You can use the &lt;code&gt;form&lt;/code&gt; package by itself it you
want more control over the error message or you can use the &lt;code&gt;flight&lt;/code&gt; package
which handles the error message for you:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Without flight
if valid, missingField := form.Required(r, &amp;quot;email&amp;quot;, &amp;quot;password&amp;quot;); !valid {
	sess.AddFlash(flash.Info{&amp;quot;Field missing: &amp;quot; + missingField, flash.Error})
	sess.Save(r, w)
	LoginGET(w, r)
	return
}

// With flight
c := flight.Context(w, r)
if !c.FormValid(&amp;quot;name&amp;quot;, &amp;quot;email&amp;quot;, &amp;quot;password&amp;quot;) {
	Create(w, r)
	return
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;repopulate-form-fields&#34;&gt;Repopulate Form Fields&lt;/h2&gt;

&lt;p&gt;The &lt;strong&gt;form&lt;/strong&gt; package can also repopulate the form fields after a submission that
is missing information. It is also a
variadic function so it can accepts more than one field. You&amp;rsquo;ll need to use
blocks from the &lt;strong&gt;form&lt;/strong&gt; package in your view as well. Check out the
&lt;a href=&#34;https://blue-jay.github.io/views/#repopulate-form-fields&#34;&gt;Views&lt;/a&gt; page to see how to use them.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Without flight
c := flight.Context(w, r)
v := c.View.New(&amp;quot;note/create&amp;quot;)
form.Repopulate(r.Form, v.Vars, &amp;quot;name&amp;quot;)
v.Render(w, r)

// With flight
c := flight.Context(w, r)
v := c.View.New(&amp;quot;note/create&amp;quot;)
c.Repopulate(v.Vars, &amp;quot;name&amp;quot;)
v.Render(w, r)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;render-a-template&#34;&gt;Render a Template&lt;/h2&gt;

&lt;p&gt;You can render a template a few ways (check out the &lt;a href=&#34;https://blue-jay.github.io/views&#34;&gt;Views&lt;/a&gt;
page for more clarification):&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Render without adding any variables
c := flight.Context(w, r)
c.View.New(&amp;quot;about/index&amp;quot;).Render(w, r)

// Render with variables
c := flight.Context(w, r)
v := c.View.New(&amp;quot;home/index&amp;quot;)
v.Vars[&amp;quot;first_name&amp;quot;] = c.Sess.Values[&amp;quot;first_name&amp;quot;]
v.Render(w, r)

// Render with different base template (base.tmpl is used by default)
c := flight.Context(w, r)
v := c.View.New(&amp;quot;home/index&amp;quot;).Base(&amp;quot;single&amp;quot;)
v.Render(w, r)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;return-flash-over-ajax&#34;&gt;Return Flash over Ajax&lt;/h2&gt;

&lt;p&gt;If you&amp;rsquo;re using Ajax to retrieve content, you can also retrieve the flash
messages this way so they can be displayed without refreshing the page. There is
JavaScript that is already designed to show a Flash message and it&amp;rsquo;s called:
&lt;strong&gt;ShowFlash()&lt;/strong&gt;. You&amp;rsquo;ll just need to make a call to the page and then pass the
output to &lt;strong&gt;ShowFlash()&lt;/strong&gt;. The code is below.&lt;/p&gt;

&lt;p&gt;Code for the controller:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Load the routes.
func Load() {
	router.Get(&amp;quot;/flashes&amp;quot;, Index)
}

// Index displays the flash messages in JSON.
func Index(w http.ResponseWriter, r *http.Request) {
	c := flight.Context(w, r)

	// Set the flash message
	c.Sess.AddFlash(flash.Info{&amp;quot;An error occurred on the server. Please try again later.&amp;quot;, flash.Error})
	c.Sess.Save(r, w)

	// Display the flash messages as JSON
	flash.SendFlashes(w, r)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Code in JavaScript:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-javascript&#34;&gt;$.get(&amp;quot;/flashes&amp;quot;, function(data) {
	showFlash(data);
});
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;interact-with-a-model&#34;&gt;Interact with a Model&lt;/h2&gt;

&lt;p&gt;The models contain all the SQL code so the controllers just call the model
functions to interact with the data.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Get database result
result, norows, err := user.ByEmail(email)

if nowrows {
	// User does not exist
} else if err != nil {
	// Display error message
} else if passhash.MatchString(result.Password, password) {
	// Password matches!
} else {
	// Password does not match
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;send-an-email&#34;&gt;Send an Email&lt;/h2&gt;

&lt;p&gt;There is also a simple package that sends emails once the SMTP settings in
env.json point to your SMTP server.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Email a user
c := flight.Context(w, r)
err := c.Config.Email.Send(&amp;quot;This is the subject&amp;quot;, &amp;quot;This is the body!&amp;quot;)
if err != nil {
	c.FlashError(err)
	return
}
&lt;/code&gt;&lt;/pre&gt;
</description>
    </item>
    
    <item>
      <title>Models</title>
      <link>https://blue-jay.github.io/models/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/models/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;It&amp;rsquo;s a good idea to abstract the database layer out so if you need to make
changes, you don&amp;rsquo;t have to look through the controllers to find the queries. All
the queries are stored in the &lt;strong&gt;model&lt;/strong&gt; folder.&lt;/p&gt;

&lt;p&gt;Blue Jay supports MySQL by default, but can easily be expanded to use other
database systems. There is also a PostgreSQL package you can use
&lt;a href=&#34;https://github.com/blue-jay/core/blob/master/storage/driver/postgresql/postgresql.go&#34;&gt;here&lt;/a&gt;.
The instructions are at the bottom of this page.&lt;/p&gt;

&lt;h2 id=&#34;connect-to-the-database&#34;&gt;Connect to the database&lt;/h2&gt;

&lt;p&gt;You only need to connect to the database once. The connection pool is
handled by the &lt;a href=&#34;https://github.com/go-sql-driver/mysql&#34;&gt;go-sql-driver/mysql&lt;/a&gt;
package. The connection is started by the &lt;strong&gt;lib/boot&lt;/strong&gt; package:&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/lib/boot/boot.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Connect to the MySQL database
mysqlDB, _ := config.MySQL.Connect(true)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;model-layout&#34;&gt;Model Layout&lt;/h2&gt;

&lt;p&gt;Every model should have a table name, a struct to represent the columns, and a
Connection interface. The interface makes the model much more testable so it can
be easily mocked and interchanged.&lt;/p&gt;

&lt;p&gt;A good interface for each model looks like this:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;// Connection is an interface for making queries.
type Connection interface {
    Exec(query string, args ...interface{}) (sql.Result, error)
    Get(dest interface{}, query string, args ...interface{}) error
    Select(dest interface{}, query string, args ...interface{}) error
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;And a good create function looks like this:&lt;/p&gt;

&lt;pre&gt;&lt;code&gt;// Create adds an item.
func Create(db Connection, name string, userID string) (sql.Result, error) {
    result, err := db.Exec(fmt.Sprintf(`
        INSERT INTO %v
        (name, user_id)
        VALUES
        (?,?)
        `, table),
        name, userID)
    return result, err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;crud-operations&#34;&gt;CRUD Operations&lt;/h1&gt;

&lt;p&gt;Below are common operations and how controllers can interact with models.
All the controller functions are from
&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/controller/notepad/notepad.go&#34;&gt;notepad.go&lt;/a&gt;
and the model functions
are from &lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/model/note/note.go&#34;&gt;note.go&lt;/a&gt;.&lt;/p&gt;

&lt;h2 id=&#34;create-an-item&#34;&gt;Create an Item&lt;/h2&gt;

&lt;p&gt;Use &lt;strong&gt;db.Exec()&lt;/strong&gt; to create an item or a table.&lt;/p&gt;

&lt;h3 id=&#34;controller&#34;&gt;Controller&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Store handles the create form submission.
func Store(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    if !c.FormValid(&amp;quot;name&amp;quot;) {
        Create(w, r)
        return
    }

    _, err := note.Create(c.DB, r.FormValue(&amp;quot;name&amp;quot;), c.UserID)
    if err != nil {
        c.FlashError(err)
        Create(w, r)
        return
    }

    c.FlashSuccess(&amp;quot;Item added.&amp;quot;)
    c.Redirect(uri)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;model&#34;&gt;Model&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Create adds an item.
func Create(db Connection, name string, userID string) (sql.Result, error) {
    result, err := db.Exec(fmt.Sprintf(`
        INSERT INTO %v
        (name, user_id)
        VALUES
        (?,?)
        `, table),
        name, userID)
    return result, err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;get-an-item-by-item-id&#34;&gt;Get an Item by Item ID&lt;/h2&gt;

&lt;p&gt;Use &lt;strong&gt;db.Get()&lt;/strong&gt; to get a single item.&lt;/p&gt;

&lt;h3 id=&#34;controller-1&#34;&gt;Controller&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Show displays a single item.
func Show(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    item, _, err := note.ByID(c.DB, c.Param(&amp;quot;id&amp;quot;), c.UserID)
    if err != nil {
        c.FlashError(err)
        c.Redirect(uri)
        return
    }

    v := c.View.New(&amp;quot;note/show&amp;quot;)
    v.Vars[&amp;quot;item&amp;quot;] = item
    v.Render(w, r)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;model-1&#34;&gt;Model&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// ByID gets item by ID.
func ByID(db Connection, ID string, userID string) (Item, bool, error) {
    result := Item{}
    err := db.Get(&amp;amp;result, fmt.Sprintf(`
        SELECT id, name, user_id, created_at, updated_at, deleted_at
        FROM %v
        WHERE id = ?
            AND user_id = ?
            AND deleted_at IS NULL
        LIMIT 1
        `, table),
        ID, userID)
    return result, err == sql.ErrNoRows, err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;get-items-by-user-id&#34;&gt;Get Items by User ID&lt;/h2&gt;

&lt;p&gt;Use &lt;strong&gt;db.Select()&lt;/strong&gt; to get multiple items.&lt;/p&gt;

&lt;h3 id=&#34;controller-2&#34;&gt;Controller&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Index displays the items.
func Index(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    items, _, err := note.ByUserID(c.DB, c.UserID)
    if err != nil {
        c.FlashError(err)
        items = []note.Item{}
    }

    v := c.View.New(&amp;quot;note/index&amp;quot;)
    v.Vars[&amp;quot;items&amp;quot;] = items
    v.Render(w, r)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;model-2&#34;&gt;Model&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// ByUserID gets all entities for a user.
func ByUserID(db Connection, userID string) ([]Item, bool, error) {
    var result []Item
    err := db.Select(&amp;amp;result, fmt.Sprintf(`
        SELECT id, name, user_id, created_at, updated_at, deleted_at
        FROM %v
        WHERE user_id = ?
            AND deleted_at IS NULL
        `, table),
        userID)
    return result, err == sql.ErrNoRows, err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;update-an-item&#34;&gt;Update an Item&lt;/h2&gt;

&lt;p&gt;Use &lt;strong&gt;db.Exec()&lt;/strong&gt; to update one or more items.&lt;/p&gt;

&lt;h3 id=&#34;controller-3&#34;&gt;Controller&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Update handles the edit form submission.
func Update(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    if !c.FormValid(&amp;quot;name&amp;quot;) {
        Edit(w, r)
        return
    }

    _, err := note.Update(c.DB, r.FormValue(&amp;quot;name&amp;quot;), c.Param(&amp;quot;id&amp;quot;), c.UserID)
    if err != nil {
        c.FlashError(err)
        Edit(w, r)
        return
    }

    c.FlashSuccess(&amp;quot;Item updated.&amp;quot;)
    c.Redirect(uri)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;model-3&#34;&gt;Model&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Update makes changes to an existing item.
func Update(db Connection, name string, ID string, userID string) (sql.Result, error) {
    result, err := db.Exec(fmt.Sprintf(`
        UPDATE %v
        SET name = ?
        WHERE id = ?
            AND user_id = ?
            AND deleted_at IS NULL
        LIMIT 1
        `, table),
        name, ID, userID)
    return result, err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;soft-delete-an-item&#34;&gt;Soft Delete an Item&lt;/h2&gt;

&lt;p&gt;A soft delete leaves the item in the database, but marks it as deleted with a
timestamp.&lt;/p&gt;

&lt;h3 id=&#34;controller-4&#34;&gt;Controller&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Destroy handles the delete form submission.
func Destroy(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    _, err := note.DeleteSoft(c.DB, c.Param(&amp;quot;id&amp;quot;), c.UserID)
    if err != nil {
        c.FlashError(err)
    } else {
        c.FlashNotice(&amp;quot;Item deleted.&amp;quot;)
    }

    c.Redirect(uri)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;model-4&#34;&gt;Model&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Delete marks an item as removed.
func DeleteSoft(db Connection, ID string, userID string) (sql.Result, error) {
    result, err := db.Exec(fmt.Sprintf(`
        UPDATE %v
        SET deleted_at = NOW()
        WHERE id = ?
            AND user_id = ?
            AND deleted_at IS NULL
        LIMIT 1
        `, table),
        ID, userID)
    return result, err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;hard-delete-an-item&#34;&gt;Hard Delete an Item&lt;/h2&gt;

&lt;p&gt;A hard delete removes the item from the database.&lt;/p&gt;

&lt;h3 id=&#34;controller-5&#34;&gt;Controller&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Destroy handles the delete form submission.
func Destroy(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    _, err := note.DeleteHard(c.DB, c.Param(&amp;quot;id&amp;quot;), c.UserID)
    if err != nil {
        c.FlashError(err)
    } else {
        c.FlashNotice(&amp;quot;Item deleted.&amp;quot;)
    }

    c.Redirect(uri)
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h3 id=&#34;model-5&#34;&gt;Model&lt;/h3&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// DeleteHard removes an item.
func DeleteHard(db Connection, ID string, userID string) (sql.Result, error) {
    result, err := db.Exec(fmt.Sprintf(`
        DELETE FROM %v
        WHERE id = ?
            AND user_id = ?
            AND deleted_at IS NULL
        `, table),
        ID, userID)
    return result, err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;postgresql-support&#34;&gt;PostgreSQL Support&lt;/h2&gt;

&lt;p&gt;To use PostgreSQL, you need to a few lines of code. The migration support is
not built into &lt;a href=&#34;https://github.com/blue-jay/jay&#34;&gt;Jay&lt;/a&gt; yet so you&amp;rsquo;ll have to run
them manually.&lt;/p&gt;

&lt;p&gt;Add the PostgreSQL structure to the env.json.example file:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;&amp;quot;PostgreSQL&amp;quot;:{
    &amp;quot;Username&amp;quot;:&amp;quot;root&amp;quot;,
    &amp;quot;Password&amp;quot;:&amp;quot;&amp;quot;,
    &amp;quot;Database&amp;quot;:&amp;quot;blueprint&amp;quot;,
    &amp;quot;Hostname&amp;quot;:&amp;quot;127.0.0.1&amp;quot;,
    &amp;quot;Port&amp;quot;:5432,
    &amp;quot;Parameter&amp;quot;:&amp;quot;&amp;quot;,
    &amp;quot;MigrationFolder&amp;quot;:&amp;quot;migration/postgresql&amp;quot;,
    &amp;quot;Extension&amp;quot;:&amp;quot;sql&amp;quot;
},
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Ensure the JSON is readable by to the &lt;strong&gt;Info&lt;/strong&gt; struct in &lt;strong&gt;lib/env&lt;/strong&gt; so add this
line:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;PostgreSQL postgresql.Info `json:&amp;quot;PostgreSQL&amp;quot;`
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Add these lines to the &lt;strong&gt;RegisterServices()&lt;/strong&gt; function in &lt;strong&gt;lib/boot&lt;/strong&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Connect to the PostgreSQL database
postgresqldb, _ := config.PostgreSQL.Connect(true)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;If you want to replace MySQL, you can change the line at the bottom of the
&lt;strong&gt;RegisterServices()&lt;/strong&gt; function in &lt;strong&gt;lib/boot&lt;/strong&gt; to pass PostgreSQL instead of
MySQL:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Store the database connection in flight
flight.StoreDB(postgresqldb)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;If you want to add instead of replacing MySQL, you need to:
- Add a new function to the &lt;strong&gt;lib/flight&lt;/strong&gt; package similar to &lt;strong&gt;StoreDB()&lt;/strong&gt;
- And a new line to the &lt;strong&gt;Info&lt;/strong&gt; struct in the &lt;strong&gt;lib/flight&lt;/strong&gt;
- Add the new variable to the &lt;strong&gt;Context()&lt;/strong&gt; function in &lt;strong&gt;lib/flight&lt;/strong&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Views</title>
      <link>https://blue-jay.github.io/views/</link>
      <pubDate>Tue, 08 Mar 2016 21:07:13 +0100</pubDate>
      
      <guid>https://blue-jay.github.io/views/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;Views contain the HTML served by your application and separate your controller/application logic from your presentation logic. The views are parsed by the &lt;a href=&#34;https://golang.org/pkg/html/template/&#34;&gt;html/template&lt;/a&gt; package.&lt;/p&gt;

&lt;p&gt;A view should include the four &lt;strong&gt;define&lt;/strong&gt; blocks (&lt;strong&gt;title&lt;/strong&gt;, &lt;strong&gt;head&lt;/strong&gt;, &lt;strong&gt;content&lt;/strong&gt;, and &lt;strong&gt;foot&lt;/strong&gt;) and may look like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;{{define &amp;quot;title&amp;quot;}}About Blueprint{{end}}
{{define &amp;quot;head&amp;quot;}}{{end}}
{{define &amp;quot;content&amp;quot;}}
	&amp;lt;div class=&amp;quot;page-header&amp;quot;&amp;gt;
		&amp;lt;h1&amp;gt;{{template &amp;quot;title&amp;quot; .}}&amp;lt;/h1&amp;gt;
	&amp;lt;/div&amp;gt;
	&amp;lt;p&amp;gt;Blueprint lays the foundation for your web application using the Go language.&amp;lt;/p&amp;gt;
	{{template &amp;quot;footer&amp;quot; .}}
{{end}}
{{define &amp;quot;foot&amp;quot;}}{{end}}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Since this view is stored at &lt;strong&gt;view/about/index.tmpl&lt;/strong&gt;, we render it using the &lt;strong&gt;view&lt;/strong&gt; helper package like so:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// import &amp;quot;github.com/blue-jay/core/view&amp;quot;
c := flight.Context(w, r)
v := c.View.New(&amp;quot;about/index&amp;quot;)
// Variables would go here like this: v.Vars[&amp;quot;first_name&amp;quot;] = session.Values[&amp;quot;first_name&amp;quot;]
v.Render(w, r)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;If you don&amp;rsquo;t have to pass any variables to the template, you could shorten it like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// import &amp;quot;github.com/blue-jay/core/view&amp;quot;
c := flight.Context(w, r)
c.View.New(&amp;quot;about/index&amp;quot;).Render(w, r)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;base-template&#34;&gt;Base Template&lt;/h2&gt;

&lt;p&gt;By default, the &lt;strong&gt;view/base.tmpl&lt;/strong&gt; template is used as the base template (as specified in env.json). If you want to
change the base template for a template, you can try this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;c := flight.Context(w, r)
v := c.View.New(&amp;quot;about/index&amp;quot;).Base(&amp;quot;alternate&amp;quot;)
v.Render(w, r)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;A shorter way to specify the view with a different base template and then render is like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;c := flight.Context(w, r)
c.View.New(&amp;quot;about/about&amp;quot;).Base(&amp;quot;alternate&amp;quot;).Render(w, r)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;view-package&#34;&gt;View Package&lt;/h2&gt;

&lt;p&gt;The &lt;strong&gt;core/view&lt;/strong&gt; package is a wrapper for the Go
&lt;a href=&#34;https://golang.org/pkg/html/template/&#34;&gt;html/template&lt;/a&gt; package and provides the
following:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;thread-safe template caching&lt;/li&gt;
&lt;li&gt;ability to extend the list of functions available in templates&lt;/li&gt;
&lt;li&gt;ability to modify the variables available in templates&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The set up of the &lt;strong&gt;view&lt;/strong&gt; package is handled by the &lt;strong&gt;lib/boot&lt;/strong&gt; package. The
config is then passed to &lt;code&gt;flight&lt;/code&gt; so it can be accessed by controllers.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Set up the views
config.View.SetTemplates(config.Template.Root, config.Template.Children)

// Set up the functions for the views
config.View.SetFuncMaps(
	config.Asset.Map(config.View.BaseURI),
	link.Map(config.View.BaseURI),
	noescape.Map(),
	prettytime.Map(),
	form.Map(),
)

// Set up the variables and modifiers for the views
config.View.SetModifiers(
	authlevel.Modify,
	uri.Modify,
	xsrf.Token,
	flash.Modify,
)

// Store the variables in flight
flight.StoreConfig(*config)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;organization&#34;&gt;Organization&lt;/h2&gt;

&lt;p&gt;The HTML templates are organized in folders under the &lt;strong&gt;view&lt;/strong&gt; folder:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-text&#34;&gt;about/index.tmpl	 - quick blurb about the app
home/index.tmpl      - public and authenticated home page
login/index.tmpl     - login page
note/create.tmpl	 - create a note
note/edit.tmpl		 - edit a note
note/index.tmpl		 - view all notes
note/show.tmpl		 - view a note
partial/favicon.tmpl - favicon metadata generated by gulpfile.js
partial/footer.tmpl	 - footer at the bottom of all pages
partial/menu.tmpl	 - menu at the top of all pages
register/index.tmpl	 - register page
base.tmpl            - base template for all pages
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;view-functions&#34;&gt;View Functions&lt;/h2&gt;

&lt;p&gt;The Go template packages supports passing a FuncMap which maps names to a
function. This means you can add functions so they are available to the views.
These functions are stored in the &lt;strong&gt;viewfunc&lt;/strong&gt; folder. Here is an example of a
&lt;strong&gt;LINK&lt;/strong&gt; function that can be used to create hyperlinks and the code is stored in
&lt;strong&gt;viewfunc/link/link.go&lt;/strong&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package link provides a funcmap for html/template to generate a hyperlink.
package link

import (
	&amp;quot;fmt&amp;quot;
	&amp;quot;html/template&amp;quot;
)

// Map returns a template.FuncMap for LINK that returns a hyperlink tag.
func Map(baseURI string) template.FuncMap {
	f := make(template.FuncMap)

	f[&amp;quot;LINK&amp;quot;] = func(path, name string) template.HTML {
		return template.HTML(fmt.Sprintf(`&amp;lt;a href=&amp;quot;%v%v&amp;quot;&amp;gt;%v&amp;lt;/a&amp;gt;`, baseURI, path, name))
	}

	return f
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To use this function in a template, you would write it like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;{{LINK &amp;quot;register&amp;quot; &amp;quot;Create a new account.&amp;quot;}}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;And the code would render like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;a href=&amp;quot;/register&amp;quot;&amp;gt;Create a new account.&amp;lt;/a&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Once you create a new funcmap, you make it available to the views by adding it
to the &lt;strong&gt;view.SetFuncMaps()&lt;/strong&gt; function in the &lt;strong&gt;lib/boot/boot.go&lt;/strong&gt; file:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Set up the functions for the views
config.View.SetFuncMaps(
	config.Asset.Map(config.View.BaseURI),
	link.Map(config.View.BaseURI),
	noescape.Map(),
	prettytime.Map(),
	form.Map(),
)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;included-functions&#34;&gt;Included Functions&lt;/h2&gt;

&lt;p&gt;There are a few functions that are included to make working with the templates
and static files easier:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;!-- CSS file with media attribute --&amp;gt;
{{CSS &amp;quot;static/css/normalize3.0.0.min.css&amp;quot; &amp;quot;all&amp;quot;}}
&amp;lt;!-- parses with timestamp to --&amp;gt;
&amp;lt;link media=&amp;quot;all&amp;quot; rel=&amp;quot;stylesheet&amp;quot; type=&amp;quot;text/css&amp;quot; href=&amp;quot;/static/css/normalize3.0.0.min.css?1435528339&amp;quot; /&amp;gt;

&amp;lt;!-- JS file --&amp;gt;
{{JS &amp;quot;static/js/jquery1.11.0.min.js&amp;quot;}}
&amp;lt;!-- parses with timestamp to --&amp;gt;
&amp;lt;script type=&amp;quot;text/javascript&amp;quot; src=&amp;quot;/static/js/jquery1.11.0.min.js?1435528404&amp;quot;&amp;gt;&amp;lt;/script&amp;gt;

&amp;lt;!-- Hyperlinks --&amp;gt;
{{LINK &amp;quot;register&amp;quot; &amp;quot;Create a new account.&amp;quot;}}
&amp;lt;!-- parses to --&amp;gt;
&amp;lt;a href=&amp;quot;/register&amp;quot;&amp;gt;Create a new account.&amp;lt;/a&amp;gt;

&amp;lt;!-- Output an unescaped variable (not a safe idea, but it is useful when troubleshooting) --&amp;gt;
{{.SomeVariable | NOESCAPE}}

&amp;lt;!-- Time format for mysql.NullTime --&amp;gt;
{{NULLTIME .SomeTime}}
&amp;lt;!-- parses to format --&amp;gt;
3:04 PM 01/02/2006

&amp;lt;!-- Time format helper for mysql.NullTime that shows the latest of the two variables --&amp;gt;
{{PRETTYTIME .CreatedAt .UpdatedAt}}
&amp;lt;!-- parses to format --&amp;gt;
3:04 PM 01/02/2006
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;view-variables&#34;&gt;View Variables&lt;/h2&gt;

&lt;p&gt;There is an easy way to add variables so they are available in the views. The
&lt;strong&gt;viewmodify&lt;/strong&gt; folder contains packages that define variables in the view.Vars
map. Since you are editing the map right before it renders, it
will overwrite any other variables that were set in the controllers so it&amp;rsquo;s best
to choose names or pick a naming convention for your variables.&lt;/p&gt;

&lt;p&gt;You can also modify the view.Info struct before it renders
if you need to display a different view or use a different base template.&lt;/p&gt;

&lt;p&gt;In the &lt;strong&gt;viewmodify/authlevel/authlevel.go&lt;/strong&gt; file, the &lt;strong&gt;AuthLevel&lt;/strong&gt; variable is
made available so the views can determine if the user is authenticated or not:&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/viewmodify/authlevel/authlevel.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package authlevel adds an AuthLevel variable to the view template.
package authlevel

import (
	&amp;quot;net/http&amp;quot;

	&amp;quot;github.com/blue-jay/blueprint/lib/flight&amp;quot;
	&amp;quot;github.com/blue-jay/core/view&amp;quot;
)

// Modify sets AuthLevel in the template to auth if the user is authenticated.
// Sets AuthLevel to anon if not authenticated.
func Modify(w http.ResponseWriter, r *http.Request, v *view.Info) {
	c := flight.Context(w, r)

	// Set the AuthLevel to auth if the user is logged in
	if c.Sess.Values[&amp;quot;id&amp;quot;] != nil {
		v.Vars[&amp;quot;AuthLevel&amp;quot;] = &amp;quot;auth&amp;quot;
	} else {
		v.Vars[&amp;quot;AuthLevel&amp;quot;] = &amp;quot;anon&amp;quot;
	}
}

&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To use the variable, you could write this type of logic into your view:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;{{if eq .AuthLevel &amp;quot;auth&amp;quot;}}
You are logged in.
{{else}}
You are not logged in.
{{end}}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Once you create a new package, you make it available to the views by adding it
to the &lt;strong&gt;view.SetModifiers()&lt;/strong&gt; function in the &lt;strong&gt;lib/boot/boot.go&lt;/strong&gt; file:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Set up the variables and modifiers for the views
config.View.SetModifiers(
	authlevel.Modify,
	uri.Modify,
	xsrf.Token,
	flash.Modify,
)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;included-variables&#34;&gt;Included Variables&lt;/h2&gt;

&lt;p&gt;There are a few included variables you can use in templates:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;!-- Use AuthLevel=auth to determine if a user is logged in (if session.Values[&amp;quot;id&amp;quot;] != nil) --&amp;gt;
{{if eq .AuthLevel &amp;quot;auth&amp;quot;}}
You are logged in.
{{else}}
You are not logged in.
{{end}}

&amp;lt;!-- Use BaseURI to print the base URL specified in the env.json file, ends in slash --&amp;gt;
&amp;lt;li&amp;gt;&amp;lt;a href=&amp;quot;{{.BaseURI}}about&amp;quot;&amp;gt;About&amp;lt;/a&amp;gt;&amp;lt;/li&amp;gt;
&amp;lt;!-- Use CurrentURI to print the current URL, does not end in slash --&amp;gt;
&amp;lt;li&amp;gt;&amp;lt;a href=&amp;quot;{{.CurrentURI}}&amp;quot;&amp;gt;Current Page&amp;lt;/a&amp;gt;&amp;lt;/li&amp;gt;
&amp;lt;!-- Use ParentURI to print the URL up one level, does not end in slash --&amp;gt;
&amp;lt;li&amp;gt;&amp;lt;a href=&amp;quot;{{.ParentURI}}&amp;quot;&amp;gt;Parent Page&amp;lt;/a&amp;gt;&amp;lt;/li&amp;gt;
&amp;lt;!-- Use GrandparentURI to print the URL up two levels, does not end in slash --&amp;gt;
&amp;lt;li&amp;gt;&amp;lt;a href=&amp;quot;{{.GrandparentURI}}&amp;quot;&amp;gt;Grandparent Page&amp;lt;/a&amp;gt;&amp;lt;/li&amp;gt;

&amp;lt;!-- Use token to output the CSRF token in a form --&amp;gt;
&amp;lt;input type=&amp;quot;hidden&amp;quot; name=&amp;quot;token&amp;quot; value=&amp;quot;{{.token}}&amp;quot;&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;repopulate-form-fields&#34;&gt;Repopulate Form Fields&lt;/h2&gt;

&lt;p&gt;When a form is submitted and there are errors like when a required field is missing,
the same web page should reload. Unfortunately, forms are not refilled so there
are a few helpers from the &lt;strong&gt;form&lt;/strong&gt; package that will help you refill, select,
and check.&lt;/p&gt;

&lt;p&gt;These functions actually do both form population (filling in a form from a
database record) and form repopulation (filling in a form from a form submission
where something went wrong like a required field was left blank). These functions
will fill the form with values from the form submission over the values from the
database record. If you refresh the page, the form submission values will be
forgotten and the values from the database record will return.&lt;/p&gt;

&lt;p&gt;For instance, say your form has two fields: name and age. Both are required fields.
You type in your name, John Doe, forget to type in your age, and click the submit
button. The page will reload, show an error message, and the functions will automatically
refill the name field with your name. The record has not been saved in the database,
but the name field is remembered from the form submission (form repopulation).
You enter in your age as 30, click the submit button, and the record is
successfully added to the database.&lt;/p&gt;

&lt;p&gt;Let&amp;rsquo;s say you want to edit the database record and you want to enter in a new
age. You load the edit page and the functions will automatically refill the
name field and the age field with the values from the database (form population).
You try to be sneaky and change your age to the word &amp;ldquo;thirty&amp;rdquo;, instead of the
number 30. You click the submit button, the page reloads, shows an error message,
and refills the name field and the age. The age field will be filled with the word
&amp;ldquo;thirty&amp;rdquo; because the form submission values take priority over the values from the
database. If you clicked the refresh button in your browser, the age field would
then load the number 30 from the database instead.&lt;/p&gt;

&lt;p&gt;There are two views that benefit from these functions: create.tmpl and edit.tmpl.
You don&amp;rsquo;t have to use these names, but it&amp;rsquo;s just an example to show you these
functions will primarily be used in the the template to create a new record
in the database (create.tmpl) and the template to edit an existing record in the
database (edit.tmpl).&lt;/p&gt;

&lt;p&gt;In the create.tmpl view, there may be required fields. If the form requires typing
in a long block of text for a couple answers and the user forgets one of the
required fields, when the page reloads, all the text will not be there. These
functions will refill, select, and check all the form inputs specified in the
controller. The create.tmpl does not use the &amp;ldquo;default value&amp;rdquo; field in these
functions so you can set them to an empty string (&amp;ldquo;&amp;rdquo;) or set them to a view
variable so you can copy and paste the same code between create.tmpl and edit.tmpl.
The edit.tmpl view requires the same logic, but also needs the &amp;ldquo;default value&amp;rdquo;
to prefill, select, and check the form values from view variables (which will
probably be pulled from a model struct).&lt;/p&gt;

&lt;p&gt;Check out the &lt;a href=&#34;https://blue-jay.github.io/controllers/#repopulate-form-fields&#34;&gt;Repopulate Form Fields&lt;/a&gt;
section on the Controllers page. It will show you the single line of code needed
in your controller so these fields repopulate on form submission.&lt;/p&gt;

&lt;p&gt;These are the functions/blocks to use in your templates. Notice that some of the HTML
attributes are missing like &lt;strong&gt;name&lt;/strong&gt;, &lt;strong&gt;value&lt;/strong&gt;, and &lt;strong&gt;type&lt;/strong&gt; from the elements.
The blocks will automatically fill these in for you so you don&amp;rsquo;t have the write
the name of the element multiple times. By the way, it took very little code to
add this functionality so check out the
&lt;a href=&#34;https://github.com/blue-jay/core/blob/master/form/form.go&#34;&gt;form&lt;/a&gt;
package to see how it was accomplished.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;!-- TEXT accepts the element name, a default value, and then a period --&amp;gt;
&amp;lt;input {{TEXT &amp;quot;email&amp;quot; .item.Email .}} type=&amp;quot;email&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;email&amp;quot; /&amp;gt;
&amp;lt;!-- then parses to a name attribute when no repopulation value is passed --&amp;gt;
&amp;lt;input name=&amp;quot;email&amp;quot; type=&amp;quot;email&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;email&amp;quot; /&amp;gt;
&amp;lt;!-- and parses to a name and a value when a repopulation value is passed --&amp;gt;
&amp;lt;input name=&amp;quot;email&amp;quot; value=&amp;quot;me@example.com&amp;quot; type=&amp;quot;email&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;email&amp;quot; /&amp;gt;

&amp;lt;!-- TEXTAREA accepts the element name, a default value, and then a period --&amp;gt;
&amp;lt;textarea rows=&amp;quot;5&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;name&amp;quot; name=&amp;quot;name&amp;quot; /&amp;gt;{{TEXTAREA &amp;quot;name&amp;quot; .item.Name .}}&amp;lt;/textarea&amp;gt;
&amp;lt;!-- then parses to nothing when no repopulation value is passed --&amp;gt;
&amp;lt;textarea rows=&amp;quot;5&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;name&amp;quot; name=&amp;quot;name&amp;quot; /&amp;gt;&amp;lt;/textarea&amp;gt;
&amp;lt;!-- and parses to a value when a repopulation value is passed --&amp;gt;
&amp;lt;textarea rows=&amp;quot;5&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;name&amp;quot; name=&amp;quot;name&amp;quot; /&amp;gt;Sample text&amp;lt;/textarea&amp;gt;

&amp;lt;!-- CHECKBOX accepts the element name, value, default value, and then a period --&amp;gt;
&amp;lt;label&amp;gt;&amp;lt;input {{CHECKBOX &amp;quot;rememberme&amp;quot; &amp;quot;r1&amp;quot; .item.RememberMe .}}&amp;gt; Remember me&amp;lt;/label&amp;gt;
&amp;lt;!-- then parses to a type, name, and value attribute when no repopulation value is passed --&amp;gt;
&amp;lt;label&amp;gt;&amp;lt;input type=&amp;quot;checkbox&amp;quot; name=&amp;quot;rememberme&amp;quot; value=&amp;quot;r1&amp;quot;&amp;gt; Remember me&amp;lt;/label&amp;gt;
&amp;lt;!-- and parses to a type, name, value, and the word &#39;checked&#39; when a repopulation value is passed --&amp;gt;
&amp;lt;label&amp;gt;&amp;lt;input type=&amp;quot;checkbox&amp;quot; name=&amp;quot;rememberme&amp;quot; value=&amp;quot;r1&amp;quot; checked&amp;gt; Remember me&amp;lt;/label&amp;gt;

&amp;lt;!-- RADIO accepts the element name, value, default value, and then a period --&amp;gt;
&amp;lt;label&amp;gt;&amp;lt;input {{RADIO &amp;quot;options&amp;quot; &amp;quot;burger&amp;quot; .item.Option .}}&amp;gt; Burger&amp;lt;/label&amp;gt;
&amp;lt;!-- then parses to a type, name, and value attribute when no repopulation value is passed --&amp;gt;
&amp;lt;label&amp;gt;&amp;lt;input type=&amp;quot;radio&amp;quot; name=&amp;quot;options&amp;quot; value=&amp;quot;burger&amp;quot;&amp;gt; Burger&amp;lt;/label&amp;gt;
&amp;lt;!-- and parses to a type, name, value attribute, and the word &#39;checked&#39; when a repopulation value is passed --&amp;gt;
&amp;lt;label&amp;gt;&amp;lt;input type=&amp;quot;radio&amp;quot; name=&amp;quot;options&amp;quot; value=&amp;quot;burger&amp;quot; checked&amp;gt; Burger&amp;lt;/label&amp;gt;

&amp;lt;!-- OPTION accepts the element name, value, default value, and then a period --&amp;gt;
&amp;lt;select name=&amp;quot;select&amp;quot;&amp;gt;&amp;lt;option {{OPTION &amp;quot;select&amp;quot; &amp;quot;Apple&amp;quot; .item.Select .}}&amp;gt;Apple&amp;lt;/option&amp;gt;&amp;lt;/select&amp;gt;
&amp;lt;!-- then parses to a value attribute when no repopulation value is passed --&amp;gt;
&amp;lt;select name=&amp;quot;select&amp;quot;&amp;gt;&amp;lt;option value=&amp;quot;Apple&amp;quot;&amp;gt;Apple&amp;lt;/option&amp;gt;&amp;lt;/select&amp;gt;
&amp;lt;!-- and parses to a value attribute and the word &#39;selected&#39; when a repopulation value is passed --&amp;gt;
&amp;lt;select name=&amp;quot;select&amp;quot;&amp;gt;&amp;lt;option value=&amp;quot;Apple&amp;quot; selected&amp;gt;Apple&amp;lt;/option&amp;gt;&amp;lt;/select&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;Here are examples of all the fields with the Bootrap structure and classes:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;div class=&amp;quot;form-group&amp;quot;&amp;gt;
	&amp;lt;label for=&amp;quot;email&amp;quot;&amp;gt;Email Address&amp;lt;/label&amp;gt;
	&amp;lt;div&amp;gt;&amp;lt;input {{TEXT &amp;quot;email&amp;quot; .item.Email .}} type=&amp;quot;email&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;email&amp;quot; maxlength=&amp;quot;48&amp;quot; placeholder=&amp;quot;Email&amp;quot; /&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;/div&amp;gt;

&amp;lt;div class=&amp;quot;form-group&amp;quot;&amp;gt;
	&amp;lt;label for=&amp;quot;name&amp;quot;&amp;gt;Item&amp;lt;/label&amp;gt;
	&amp;lt;div&amp;gt;&amp;lt;textarea rows=&amp;quot;5&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;name&amp;quot; name=&amp;quot;name&amp;quot; placeholder=&amp;quot;Type your text here...&amp;quot; /&amp;gt;{{TEXTAREA &amp;quot;name&amp;quot; .}}&amp;lt;/textarea&amp;gt;&amp;lt;/div&amp;gt;
&amp;lt;/div&amp;gt;

&amp;lt;div class=&amp;quot;checkbox&amp;quot;&amp;gt;
    &amp;lt;label&amp;gt;
        &amp;lt;input {{CHECKBOX &amp;quot;rememberme&amp;quot; &amp;quot;r1&amp;quot; .item.RememberMe .}}&amp;gt; Remember me
    &amp;lt;/label&amp;gt;
&amp;lt;/div&amp;gt;
&amp;lt;div class=&amp;quot;checkbox&amp;quot;&amp;gt;
    &amp;lt;label&amp;gt;
        &amp;lt;input {{CHECKBOX &amp;quot;rememberme&amp;quot; &amp;quot;r2&amp;quot; .item.RememberMe .}}&amp;gt; Remember me
    &amp;lt;/label&amp;gt;
&amp;lt;/div&amp;gt;

&amp;lt;div class=&amp;quot;radio&amp;quot;&amp;gt;
    &amp;lt;label&amp;gt;
        &amp;lt;input {{RADIO &amp;quot;options&amp;quot; &amp;quot;burger&amp;quot; .item.Option .}}&amp;gt; Burger
    &amp;lt;/label&amp;gt;
&amp;lt;/div&amp;gt;
&amp;lt;div class=&amp;quot;radio&amp;quot;&amp;gt;
    &amp;lt;label&amp;gt;
        &amp;lt;input {{RADIO &amp;quot;options&amp;quot; &amp;quot;taco&amp;quot; .item.Option .}}&amp;gt; Taco
    &amp;lt;/label&amp;gt;
&amp;lt;/div&amp;gt;

&amp;lt;select class=&amp;quot;form-control&amp;quot; name=&amp;quot;select&amp;quot;&amp;gt;
    &amp;lt;option {{OPTION &amp;quot;select&amp;quot; &amp;quot;Apple&amp;quot; .item.Select .}}&amp;gt;Apple&amp;lt;/option&amp;gt;
    &amp;lt;option {{OPTION &amp;quot;select&amp;quot; &amp;quot;Banana&amp;quot; .item.Select .}}&amp;gt;Banana&amp;lt;/option&amp;gt;
    &amp;lt;option {{OPTION &amp;quot;select&amp;quot; &amp;quot;cherry&amp;quot; .item.Select .}}&amp;gt;Cherry&amp;lt;/option&amp;gt;
&amp;lt;/select&amp;gt;

&amp;lt;select multiple class=&amp;quot;form-control&amp;quot; name=&amp;quot;mselect&amp;quot;&amp;gt;
    &amp;lt;option {{OPTION &amp;quot;mselect&amp;quot; &amp;quot;red&amp;quot; .item.Select .}}&amp;gt;Red&amp;lt;/option&amp;gt;
    &amp;lt;option {{OPTION &amp;quot;mselect&amp;quot; &amp;quot;green&amp;quot; .item.Select .}}&amp;gt;Green&amp;lt;/option&amp;gt;
    &amp;lt;option {{OPTION &amp;quot;mselect&amp;quot; &amp;quot;blue&amp;quot; .item.Select .}}&amp;gt;Blue&amp;lt;/option&amp;gt;
&amp;lt;/select&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;change-http-methods&#34;&gt;Change HTTP Methods&lt;/h2&gt;

&lt;p&gt;When you submit a form a a website, the site most likely sends a POST
request to the server. In order for us to make our application more RESTful, we
can use utilize the simple
&lt;a href=&#34;https://github.com/blue-jay/blueprint/blob/master/middleware/rest/rest.go&#34;&gt;&lt;strong&gt;rest&lt;/strong&gt;&lt;/a&gt;
package to change the HTTP method from a URL query string. The &lt;strong&gt;rest&lt;/strong&gt; middleware is
already applied to every request which is configured in the &lt;strong&gt;boot&lt;/strong&gt; package.&lt;/p&gt;

&lt;p&gt;To change the form method, add this line to your form action and change the value
to match a method like &lt;strong&gt;DELETE&lt;/strong&gt; or &lt;strong&gt;PATCH&lt;/strong&gt;. It will automatically
be converted to uppercase.&lt;/p&gt;

&lt;p&gt;The query string key should be: &lt;strong&gt;_method&lt;/strong&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;!-- Example of a PATCH request --&amp;gt;
&amp;lt;form method=&amp;quot;post&amp;quot; action=&amp;quot;{{$.CurrentURI}}?_method=patch&amp;quot;&amp;gt;

&amp;lt;!-- Example of a DELETE request --&amp;gt;
&amp;lt;form class=&amp;quot;button-form&amp;quot; method=&amp;quot;post&amp;quot; action=&amp;quot;{{$.GrandparentURI}}/{{.item.ID}}?_method=delete&amp;quot;&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;This is an example of a form that is updating and email and a password using the
PATCH HTTP method:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;form method=&amp;quot;post&amp;quot; action=&amp;quot;{{$.CurrentURI}}?_method=patch&amp;quot;&amp;gt;
	&amp;lt;div class=&amp;quot;form-group&amp;quot;&amp;gt;
		&amp;lt;label for=&amp;quot;email&amp;quot;&amp;gt;Email Address&amp;lt;/label&amp;gt;
		&amp;lt;div&amp;gt;&amp;lt;input {{TEXT &amp;quot;email&amp;quot; .item.Email .}} type=&amp;quot;email&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;email&amp;quot; /&amp;gt;&amp;lt;/div&amp;gt;
	&amp;lt;/div&amp;gt;

	&amp;lt;div class=&amp;quot;form-group&amp;quot;&amp;gt;
		&amp;lt;label for=&amp;quot;password&amp;quot;&amp;gt;Password&amp;lt;/label&amp;gt;
		&amp;lt;div&amp;gt;&amp;lt;input {{TEXT &amp;quot;password&amp;quot; .item.Password .}} type=&amp;quot;password&amp;quot; class=&amp;quot;form-control&amp;quot; id=&amp;quot;password&amp;quot; /&amp;gt;&amp;lt;/div&amp;gt;
	&amp;lt;/div&amp;gt;

	&amp;lt;input type=&amp;quot;submit&amp;quot; class=&amp;quot;btn btn-primary&amp;quot; value=&amp;quot;Change&amp;quot; class=&amp;quot;button&amp;quot; /&amp;gt;

	&amp;lt;input type=&amp;quot;hidden&amp;quot; name=&amp;quot;_token&amp;quot; value=&amp;quot;{{$.token}}&amp;quot;&amp;gt;
&amp;lt;/form&amp;gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The routes for this page would look something like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Display the Update Page - typical GET HTTP method
router.Get(&amp;quot;/user/edit/:id&amp;quot;, Edit, c...)

// Handle the Update Page Form Submissions - PATCH HTTP method
router.Patch(&amp;quot;user/edit/:id&amp;quot;, Update, c...)
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;header-and-footer&#34;&gt;Header and Footer&lt;/h2&gt;

&lt;p&gt;It&amp;rsquo;s also easy to add template-specific code before the closing &lt;/head&gt; and &lt;/body&gt; tags:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;&amp;lt;!-- Code is added before the closing &amp;lt;/head&amp;gt; tag --&amp;gt;
{{define &amp;quot;head&amp;quot;}}&amp;lt;meta name=&amp;quot;robots&amp;quot; content=&amp;quot;noindex&amp;quot;&amp;gt;{{end}}

...

&amp;lt;!-- Code is added before the closing &amp;lt;/body&amp;gt; tag --&amp;gt;
{{define &amp;quot;foot&amp;quot;}}{{JS &amp;quot;//www.google.com/recaptcha/api.js&amp;quot;}}{{end}}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;javascript&#34;&gt;JavaScript&lt;/h2&gt;

&lt;p&gt;There are a few built-in functions that you can use to trigger a flash notification using JavaScript.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-javascript&#34;&gt;flashError(&amp;quot;An error occurred on the server.&amp;quot;);

flashSuccess(&amp;quot;Item added!&amp;quot;);

flashNotice(&amp;quot;Item deleted.&amp;quot;);

flashWarning(&amp;quot;Field missing: email&amp;quot;);
&lt;/code&gt;&lt;/pre&gt;
</description>
    </item>
    
    <item>
      <title>Library</title>
      <link>https://blue-jay.github.io/library/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/library/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;If you look through the &lt;a href=&#34;https://github.com/blue-jay/core&#34;&gt;&lt;strong&gt;Core&lt;/strong&gt;&lt;/a&gt; library,
you&amp;rsquo;ll see packages that provide
different functionality. These packages are designed to be shared and used
through the application. Since Blueprint is a web application, some of the
packages must be thread-safe to ensure they won&amp;rsquo;t throw any errors if they are
accessed at the same time by two separate threads.&lt;/p&gt;

&lt;p&gt;As you create your own packages, you can store them in the &lt;strong&gt;blueprint/lib&lt;/strong&gt;
folder to keep them organized and separate.&lt;/p&gt;

&lt;p&gt;It&amp;rsquo;s a good idea to keep them light on dependencies so you can reuse them again
in later projects. Packages that are too tightly-coupled require time to rework
so you might as well do it right from the start.&lt;/p&gt;

&lt;p&gt;Let&amp;rsquo;s take a look at the &lt;strong&gt;email&lt;/strong&gt; package in sections. The first of the
three sections is the package declaration and import section. Notice how the
only packages the &lt;strong&gt;email&lt;/strong&gt; package uses are part of the standard library. This
is a good indicator that the package could be moved to a different project
without rewriting.&lt;/p&gt;

&lt;p&gt;&lt;a href=&#34;https://github.com/blue-jay/core/blob/master/email/email.go&#34;&gt;Source&lt;/a&gt;&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package email provides email sending via SMTP.
package email

import (
    &amp;quot;encoding/base64&amp;quot;
    &amp;quot;fmt&amp;quot;
    &amp;quot;net/smtp&amp;quot;
)
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The Info struct holds the details for the SMTP server and it should be
added to the &lt;strong&gt;Info&lt;/strong&gt; struct of the &lt;strong&gt;lib/env&lt;/strong&gt; package
and then parsed from the env.json file. See the &lt;a href=&#34;https://blue-jay.github.io/configuration/&#34;&gt;Configuration&lt;/a&gt;
section for more information about adding to env.json.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Info holds the details for the SMTP server.
type Info struct {
    Username string
    Password string
    Hostname string
    Port     int
    From     string
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The final section of the &lt;strong&gt;email&lt;/strong&gt; package sends an
email using the configuration settings. You&amp;rsquo;ll notice the function is a
struct method which makes it really easy to use from the &lt;strong&gt;flight&lt;/strong&gt; package.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Send an email.
func (c Info) Send(to, subject, body string) error {
    auth := smtp.PlainAuth(&amp;quot;&amp;quot;, c.Username, c.Password, c.Hostname)

    // Create the header
    header := make(map[string]string)
    header[&amp;quot;From&amp;quot;] = c.From
    header[&amp;quot;To&amp;quot;] = to
    header[&amp;quot;Subject&amp;quot;] = subject
    header[&amp;quot;MIME-Version&amp;quot;] = &amp;quot;1.0&amp;quot;
    header[&amp;quot;Content-Type&amp;quot;] = `text/plain; charset=&amp;quot;utf-8&amp;quot;`
    header[&amp;quot;Content-Transfer-Encoding&amp;quot;] = &amp;quot;base64&amp;quot;

    // Set the message
    message := &amp;quot;&amp;quot;
    for k, v := range header {
        message += fmt.Sprintf(&amp;quot;%s: %s\r\n&amp;quot;, k, v)
    }
    message += &amp;quot;\r\n&amp;quot; + base64.StdEncoding.EncodeToString([]byte(body))

    // Send the email
    err := smtp.SendMail(
        fmt.Sprintf(&amp;quot;%s:%d&amp;quot;, c.Hostname, c.Port),
        auth,
        c.From,
        []string{to},
        []byte(message),
    )

    return err
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To use in a controller, you would get the context from the &lt;strong&gt;flight&lt;/strong&gt; package
and then from the &lt;strong&gt;Config&lt;/strong&gt; variable, you could access the &lt;strong&gt;email&lt;/strong&gt; struct and then
the &lt;code&gt;Send()&lt;/code&gt; function.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Index sends an email.
func Index(w http.ResponseWriter, r *http.Request) {
    c := flight.Context(w, r)

    err := c.Config.Email.Send(&amp;quot;This is the subject&amp;quot;, &amp;quot;This is the body!&amp;quot;)
    if err != nil {
        c.FlashError(err)
        return
    }
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;code-generation&#34;&gt;Code Generation&lt;/h2&gt;

&lt;p&gt;A new &lt;strong&gt;lib&lt;/strong&gt; package can be generated using this command: &lt;code&gt;jay generate lib/default package:value&lt;/code&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Jay Overview</title>
      <link>https://blue-jay.github.io/jay/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/jay/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;The command-line tool, &lt;strong&gt;Jay&lt;/strong&gt;, has been mentioned throughout this documentation
quite a few times now so it&amp;rsquo;s a good time to talk a little about the tool.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Jay&lt;/strong&gt; uses the brilliant
&lt;a href=&#34;github.com/alecthomas/kingpin&#34;&gt;github.com/alecthomas/kingpin&lt;/a&gt; package to manage
the help documents, commands, subcommands, and arguments. It takes care of
groundwork so it can focus on the actual tasks.&lt;/p&gt;

&lt;p&gt;If you ever want to see the help documents for a command or subcommand, add
&lt;code&gt;-h&lt;/code&gt; or &lt;code&gt;--help&lt;/code&gt; to the end and the help documentation should be able to assist.
If you are still having problems, check out the
&lt;a href=&#34;https://godoc.org/github.com/blue-jay/jay&#34;&gt;Jay GoDoc&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;When using &lt;strong&gt;Jay&lt;/strong&gt;, there are flags, commands, and subcommands.&lt;/p&gt;

&lt;p&gt;The available flags throughout are:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;-h&lt;/code&gt; or &lt;code&gt;--help&lt;/code&gt; for help documentation&lt;/li&gt;
&lt;li&gt;&lt;code&gt;-v&lt;/code&gt; or &lt;code&gt;--version&lt;/code&gt; for version information&lt;/li&gt;
&lt;li&gt;&lt;code&gt;-c&lt;/code&gt; or &lt;code&gt;--config&lt;/code&gt; to specify the env.json config file (otherwise JAYCONFIG environment variable will be used)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The available commands are:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;jay env&lt;/code&gt; for managing the env.json file&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay find&lt;/code&gt; for locating text inside files in subfolders&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay replace&lt;/code&gt; for replacing text inside files in subfolder&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay generate&lt;/code&gt; for creating code based on templates using the &lt;strong&gt;text/template&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql&lt;/code&gt; for managing the MySQL database state&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The available subcommands are:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;jay env make&lt;/code&gt; for creating env.json from env.json.example&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay env keyshow&lt;/code&gt; for showing newly generated session keys&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay env updateshow&lt;/code&gt; for updating env.json with newly generation session keys&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql make&lt;/code&gt; for creating a new migration &amp;lsquo;up&amp;rsquo; file and &amp;lsquo;down&amp;rsquo; file&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql all&lt;/code&gt; for applying all &amp;lsquo;up&amp;rsquo; migrations&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql reset&lt;/code&gt; for applying all &amp;lsquo;down&amp;rsquo; migrations&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql refresh&lt;/code&gt; for applying all &amp;lsquo;down&amp;rsquo; then &amp;lsquo;up&amp;rsquo; migrations&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql status&lt;/code&gt; for displaying the current database state&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql up&lt;/code&gt; for applying only one &amp;lsquo;up&amp;rsquo; migration&lt;/li&gt;
&lt;li&gt;&lt;code&gt;jay migrate:mysql down&lt;/code&gt; for applying one one &amp;lsquo;down&amp;rsquo; migration&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;There is also a common syntax used by each of the commands, subcommands, and
arguments that make the help documents easy to follow.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Flags have one or two dashes in the front: &lt;code&gt;-h, --help&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Commands follow the application name (jay): &lt;code&gt;jay migrate:mysql&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Subcommands follow the command: &lt;code&gt;jay migrate:mysql make&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Arguments follow the command or subcommand: &lt;code&gt;jay migrate:mysql make &amp;lt;description&amp;gt;&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Required arguments: &lt;code&gt;&amp;lt;required&amp;gt;&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Optional arguments: &lt;code&gt;[&amp;lt;optional&amp;gt;]&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Find and Replace</title>
      <link>https://blue-jay.github.io/find-replace/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/find-replace/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Jay&lt;/strong&gt; includes the ability to do a case-sensitive find and replace. This is
great when you have many files to look through and need simple way to
find and replace quickly.&lt;/p&gt;

&lt;h2 id=&#34;find-usage&#34;&gt;Find Usage&lt;/h2&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;usage: jay find &amp;lt;folder&amp;gt; &amp;lt;text&amp;gt; [&amp;lt;extension&amp;gt;] [&amp;lt;recursive&amp;gt;] [&amp;lt;filename&amp;gt;]

Search for files containing matching text.

Flags:
  -h, --help     Show context-sensitive help (also try --help-long and
                 --help-man).
  -v, --version  Show application version.

Args:
  &amp;lt;folder&amp;gt;       Folder to search
  &amp;lt;text&amp;gt;         Case-sensitive text to find.
  [&amp;lt;extension&amp;gt;]  File name or extension to search in. Use * as a wildcard.
                 Directory names are not valid.
  [&amp;lt;recursive&amp;gt;]  True to search in subfolders. Default: true
  [&amp;lt;filename&amp;gt;]   True to include file path in results if matched. Default: false
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;replace-usage&#34;&gt;Replace Usage&lt;/h2&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;usage: jay replace &amp;lt;folder&amp;gt; &amp;lt;find&amp;gt; [&amp;lt;replace&amp;gt;] [&amp;lt;extension&amp;gt;] [&amp;lt;recursive&amp;gt;] [&amp;lt;filename&amp;gt;] [&amp;lt;commit&amp;gt;]

Search for files containing matching text and then replace it with new text.

Flags:
  -h, --help     Show context-sensitive help (also try --help-long and
                 --help-man).
  -v, --version  Show application version.

Args:
  &amp;lt;folder&amp;gt;       Folder to search
  &amp;lt;find&amp;gt;         Case-sensitive text to replace.
  [&amp;lt;replace&amp;gt;]    Text to replace with.
  [&amp;lt;extension&amp;gt;]  File name or extension to search in. Use * as a wildcard.
                 Directory names are not valid.
  [&amp;lt;recursive&amp;gt;]  True to search in subfolders. Default: true
  [&amp;lt;filename&amp;gt;]   True to include file path in results if matched. Default: false
  [&amp;lt;commit&amp;gt;]     True to makes the changes instead of just displaying them.
                 Default: true
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;find-and-replace-examples&#34;&gt;Find and Replace Examples&lt;/h2&gt;

&lt;p&gt;Here are examples are how to use find and replace:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;# Find the word &amp;quot;red&amp;quot; in all *.go files in the current folder and in subfolders.
jay find . red

# Find the word &amp;quot;red&amp;quot; in all files in the current folder only.
jay find . red &amp;quot;*.*&amp;quot; false

# Find the word &amp;quot;red&amp;quot; in *.go files in current folder and in subfolders and 
# include file paths that match also.
jay find . red &amp;quot;*.go&amp;quot; true true

# Replace the word &amp;quot;red&amp;quot; with the word &amp;quot;blue&amp;quot; in all *.go files in the current
# folder and in subfolders.
jay replace . red blue

# Replace the word &amp;quot;red&amp;quot; with the word &amp;quot;blue&amp;quot; in all *.go files in current
# folder only.
jay replace . red blue &amp;quot;*.go&amp;quot; false

# Change the name of the project in current folder and in subfolders and all
# imports to another repository.
jay replace . &amp;quot;blue-jay/blueprint&amp;quot; &amp;quot;user/project&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
</description>
    </item>
    
    <item>
      <title>Database Migration</title>
      <link>https://blue-jay.github.io/database-migration/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/database-migration/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;Database migrations are a great way to manage incremental database changes.
The migration state is stored in the same database (the one specified in
env.json) and recorded in the &lt;strong&gt;migration&lt;/strong&gt; table. This is how the
&lt;code&gt;jay migrate:mysql status&lt;/code&gt;command knows which migration was performed last.&lt;/p&gt;

&lt;p&gt;Each incremental change should have a set of two files: an &amp;lsquo;up&amp;rsquo; file and a
&amp;lsquo;down&amp;rsquo; file. The &amp;lsquo;up&amp;rsquo; file contains code (like SQL) which is applied to the
database you add features or fix bugs in your database. The &amp;lsquo;down&amp;rsquo; file contains
the code to remove the change or undo it.&lt;/p&gt;

&lt;p&gt;More than one migration can now be run on a database. You just have to specify
a different table value in the env.json file under the MySQL.Migration.Table key.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note 1&lt;/strong&gt;: The &lt;code&gt;jay migrate&lt;/code&gt; commands requires the environment variable,
&lt;strong&gt;JAYCONFIG&lt;/strong&gt;, to point to the env.json file path. The migration folder is specified
in the env.json file under &lt;strong&gt;MySQL.Migration.Folder&lt;/strong&gt;. If the environment variable
is not set, you can specify the &amp;ndash;config or -c flag and pass the path to env.json.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note 2&lt;/strong&gt;: Make sure you do not create any migrations with a date earlier than
any applied migrations. Jay will not go back and apply them. They must be
created sequentially.&lt;/p&gt;

&lt;p&gt;When you start using &lt;strong&gt;Blueprint&lt;/strong&gt; you&amp;rsquo;ll see two migration files already exist
in the &lt;strong&gt;migration/mysql&lt;/strong&gt; folder:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;20160630_020000.000000_init.up.sql - adds the initial tables and data&lt;/li&gt;
&lt;li&gt;20160630_020000.000000_init.down.sql - removes the tables and data&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Jay&lt;/strong&gt; provides a few commands to make the migrations easier. Here is a list
of the commands:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;jay migrate:mysql make &amp;quot;test&amp;quot; # Create new migration
jay migrate:mysql all         # Advance all migrations
jay migrate:mysql reset       # Rollback all migrations
jay migrate:mysql refresh     # Rollback all migrations then advance all migrations
jay migrate:mysql status      # See last &#39;up&#39; migration
jay migrate:mysql up          # Apply only the next &#39;up&#39; migration
jay migrate:mysql down        # Apply only the current &#39;down&#39; migration
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;workflow&#34;&gt;Workflow&lt;/h2&gt;

&lt;p&gt;Let&amp;rsquo;s walk through an typical workflow. Assume the &lt;strong&gt;blueprint&lt;/strong&gt; folder is the
root of a git repository. Developer Joe needs to add a feature to the
application to store books. Joe creates a new branch called feature-store-books.
He needs to create a new table called &lt;strong&gt;book&lt;/strong&gt; so he creates a new database
migration: &lt;code&gt;jay migrate:mysql make &amp;quot;feature-store-books&amp;quot;&lt;/code&gt;. He opens the &amp;lsquo;up&amp;rsquo; file
and adds the SQL query to create a new table with the following columns: title,
author, and publication_date. In the &amp;lsquo;down&amp;rsquo; file, he writes the code to drop the
table. He also writes the code to create, read, update, and
delete the books in his Go code and then performs a &lt;code&gt;git merge&lt;/code&gt; and then a
&lt;code&gt;git push&lt;/code&gt;. Developer Steve needs to add an additional column to the
&lt;strong&gt;book&lt;/strong&gt; table called: publisher. Steve performs a &lt;code&gt;git pull&lt;/code&gt; to download the
latest code from the repository. In order to update his local database to the
latest version of code, runs: &lt;code&gt;jay migrate:mysql all&lt;/code&gt;. Then, Steve creates a new
migration for the new requirement: &lt;code&gt;jay migrate:mysql make &amp;quot;feature-add-publisher&amp;quot;&lt;/code&gt;.
Steve adds the SQL &lt;code&gt;ADD COLUMN&lt;/code&gt; code to the new &amp;lsquo;up&amp;rsquo; file and the SQL
&lt;code&gt;DROP COLUMN&lt;/code&gt; code to the new &amp;lsquo;down&amp;rsquo; file and then performs a &lt;code&gt;git merge&lt;/code&gt; and a
&lt;code&gt;git push&lt;/code&gt; again.&lt;/p&gt;

&lt;h2 id=&#34;migrate-make&#34;&gt;migrate make&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;jay migrate:mysql make [description]&lt;/code&gt; command create a new &amp;lsquo;up&amp;rsquo; and &amp;lsquo;down&amp;rsquo;
migration in the &lt;strong&gt;database/migration&lt;/strong&gt; folder.&lt;/p&gt;

&lt;h2 id=&#34;migrate-all&#34;&gt;migrate all&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;jay migrate:mysql all&lt;/code&gt; command finds the current status of the database and then
applies all the code from each of the &amp;lsquo;up&amp;rsquo; files in chronological order based on
filename.&lt;/p&gt;

&lt;h2 id=&#34;migrate-reset&#34;&gt;migrate reset&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;jay migrate:mysql reset&lt;/code&gt; command finds the current status of the database and
then applies all the code from each of the &amp;lsquo;down&amp;rsquo; files in reverse chronological
order based on filename which should remove all tables and data with the
exception of an an empty &lt;strong&gt;migration&lt;/strong&gt; table.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note:&lt;/strong&gt; If any tables were created outside of the migrations, they should
still be in the database.&lt;/p&gt;

&lt;h2 id=&#34;migrate-refresh&#34;&gt;migrate refresh&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;jay migrate:mysql refresh&lt;/code&gt; command runs a &lt;code&gt;jay migrate reset&lt;/code&gt; and then applies
all the code from each of the &amp;lsquo;up&amp;rsquo; files in chronological order based on
filename.&lt;/p&gt;

&lt;h2 id=&#34;migrate-status&#34;&gt;migrate status&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;jay migrate:mysql status&lt;/code&gt; command reads the latest record in the &lt;strong&gt;migration&lt;/strong&gt;
table which is the last &amp;lsquo;up&amp;rsquo; file that was applied to the database.&lt;/p&gt;

&lt;h2 id=&#34;migrate-up&#34;&gt;migrate up&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;jay migrate:mysql up&lt;/code&gt; command applies only the code in the next &amp;lsquo;up&amp;rsquo; file in
chronological order based on filename.&lt;/p&gt;

&lt;h2 id=&#34;migrate-down&#34;&gt;migrate down&lt;/h2&gt;

&lt;p&gt;The &lt;code&gt;jay migrate:mysql down&lt;/code&gt; command applies only the code in the current &amp;lsquo;down&amp;rsquo; file.&lt;/p&gt;

&lt;h2 id=&#34;other-database-changes&#34;&gt;Other Database Changes&lt;/h2&gt;

&lt;p&gt;If the &amp;lsquo;up&amp;rsquo; and &amp;lsquo;down&amp;rsquo; files are written properly, tables created manually
outside the migrations should be left untouched by the &lt;code&gt;jay migrate&lt;/code&gt; commands.
The only changes &lt;code&gt;jay migrate&lt;/code&gt; makes to the database outside of the migrations
are the creation of the database itself based on the settings in env.json and
the modification of the &lt;strong&gt;migration&lt;/strong&gt; table.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Code Generation</title>
      <link>https://blue-jay.github.io/generation/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://blue-jay.github.io/generation/</guid>
      <description>

&lt;h2 id=&#34;basic-usage&#34;&gt;Basic Usage&lt;/h2&gt;

&lt;p&gt;Code generation makes it easy to build out new features so you don&amp;rsquo;t have to
retype or copy and paste the same code over again. It&amp;rsquo;s especially useful when
prototyping and need to see how something will look or work.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Note&lt;/strong&gt;: The &lt;code&gt;jay generate&lt;/code&gt; commands requires the environment variable,
&lt;strong&gt;JAYCONFIG&lt;/strong&gt;, to point to the env.json file path. The generation folder
containing the templates is specified in the env.json file under
&lt;strong&gt;Generation.TemplateFolder&lt;/strong&gt;.  If the environment variable
is not set, you can specify the &amp;ndash;config or -c flag and pass the path to env.json.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Jay&lt;/strong&gt; tries to make it easy to generate code by using tools that you already
know: the &lt;strong&gt;text/template&lt;/strong&gt; package from the standard Go library and JSON.&lt;/p&gt;

&lt;p&gt;A template pair consists of a .json file and a .gen file. The .gen file contains
the &lt;strong&gt;text/template&lt;/strong&gt; parsable code. The .json file contains other information
needed for the generation process like:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;config.type - either &amp;lsquo;single&amp;rsquo; if creating one file or &amp;lsquo;collection&amp;rsquo; if referencing one or more other .json files&lt;/li&gt;
&lt;li&gt;config.output - relative path at which to create the file&lt;/li&gt;
&lt;li&gt;config.parse - either true or false&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In the .json file, any other keys outside these three will be applied directly
to the .gen file. If you leave a key blank, that tells &lt;code&gt;jay generate&lt;/code&gt; that it
needs to be passed via command-line.&lt;/p&gt;

&lt;p&gt;Don&amp;rsquo;t worry, there are already a boatload of templates ready to use. They are
organized by type in the &lt;strong&gt;generate&lt;/strong&gt; folder of Blueprint. If .json file does
not have a .gen pair in the same folder, then it has a &lt;strong&gt;config.parse&lt;/strong&gt; value
of &lt;strong&gt;collection&lt;/strong&gt; which means it references other .json files with a
&lt;strong&gt;config.parse&lt;/strong&gt; value of &lt;strong&gt;single&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;lib/flight&lt;/strong&gt; package is a helper package that reduces a lot of code from the
controller. It contains functions to simplify the use of flash messages,
form validation, form repopulation, and URL parameters.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;controller

&lt;ul&gt;
&lt;li&gt;bare.gen | bare.json - creates a bare controller with only placeholder functions&lt;/li&gt;
&lt;li&gt;default.gen | default.json - creates a controller with CRUD ready code with the &lt;strong&gt;flight&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;nameonly.gen | nameonly.json - creates a controller with CRUD ready code with the &lt;strong&gt;flight&lt;/strong&gt; package and only a &lt;strong&gt;name&lt;/strong&gt; column&lt;/li&gt;
&lt;li&gt;noflight.gen | noflight.json - creates a controller with CRUD ready code without the &lt;strong&gt;flight&lt;/strong&gt; package&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;crud

&lt;ul&gt;
&lt;li&gt;bare.json - creates a bare controller, model, and four views&lt;/li&gt;
&lt;li&gt;default.json - creates a controller, model, and four views CRUD ready with the &lt;strong&gt;flight&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;nameonly.json - creates a controller, model, and four views CRUD ready with the &lt;strong&gt;flight&lt;/strong&gt; package and only a &lt;strong&gt;name&lt;/strong&gt; column&lt;/li&gt;
&lt;li&gt;noflight.json - creates a controller, model, and four views CRUD ready without the &lt;strong&gt;flight&lt;/strong&gt; package&lt;/li&gt;
&lt;li&gt;table.json - creates a controller, model, and four views CRUD ready with the &lt;strong&gt;flight&lt;/strong&gt; package and only a &lt;strong&gt;name&lt;/strong&gt; column that displays in a table view&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;lib

&lt;ul&gt;
&lt;li&gt;default.gen | default.json - creates a thread-safe wrapper package&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;middleware

&lt;ul&gt;
&lt;li&gt;default.gen | default.json - creates a middleware package&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;model

&lt;ul&gt;
&lt;li&gt;bare.gen | bare.json - creates a bare model with only placeholder functions&lt;/li&gt;
&lt;li&gt;default.gen | default.json - creates a model with CRUD ready code&lt;/li&gt;
&lt;li&gt;nameonly.gen | nameonly.json - creates a model with CRUD ready code and only a &lt;strong&gt;name&lt;/strong&gt; column&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;view

&lt;ul&gt;
&lt;li&gt;bare.json - creates four bare views with only a basic structure&lt;/li&gt;
&lt;li&gt;create.gen | create.json - creates a CRUD ready creation form view&lt;/li&gt;
&lt;li&gt;create_bare.gen | create_bare.json - creates a bare view with only a basic structure&lt;/li&gt;
&lt;li&gt;default.json - creates four views with CRUD ready code&lt;/li&gt;
&lt;li&gt;edit.gen | edit.json - creates a CRUD ready edit form view&lt;/li&gt;
&lt;li&gt;edit_bare.gen | edit_bare.json - creates a bare view with only a basic structure&lt;/li&gt;
&lt;li&gt;index.gen | index.json - creates a CRUD ready display view for multiple items&lt;/li&gt;
&lt;li&gt;index_bare.gen | index_bare.json - creates a bare view with only a basic structure&lt;/li&gt;
&lt;li&gt;index_table.gen | index_table.json - creates a CRUD ready table view for multiple items&lt;/li&gt;
&lt;li&gt;show.gen | show.json - creates a CRUD ready display view for a single item&lt;/li&gt;
&lt;li&gt;show_bare.gen | show_bare.json - creates a bare view with only a basic structure&lt;/li&gt;
&lt;li&gt;show_table.gen | show_table.json - creates a CRUD ready table view for a single item&lt;/li&gt;
&lt;li&gt;single.gen | single.json - creates a bare view with only a basic structure&lt;/li&gt;
&lt;li&gt;table.json - creates four views with CRUD ready code in a table view&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;viewfunc

&lt;ul&gt;
&lt;li&gt;default.gen | default.json - creates a FuncMap package for use with the &lt;strong&gt;html/template&lt;/strong&gt; package&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;li&gt;viewmodify

&lt;ul&gt;
&lt;li&gt;default.gen | default.json - creates a package to modify the &lt;strong&gt;lib/view&lt;/strong&gt; package before rendering&lt;/li&gt;
&lt;/ul&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Let&amp;rsquo;s view a couple examples.&lt;/p&gt;

&lt;h2 id=&#34;middleware-example&#34;&gt;Middleware Example&lt;/h2&gt;

&lt;p&gt;The &lt;strong&gt;generate/middleware/default.gen&lt;/strong&gt; file contains this template. The
{{.package}} variable is the only required variable for this template so it must
be added to the .json file as a key with blank value. This forces &lt;code&gt;jay generate&lt;/code&gt;
to require the user to pass a &lt;strong&gt;package&lt;/strong&gt; variable before it will generate the
template.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package {{.package}}
package {{.package}}

import (
    &amp;quot;net/http&amp;quot;
)

// Handler
func Handler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Logic BEFORE the other handlers and function goes here
        next.ServeHTTP(w, r)
        // Logic AFTER the other handlers and function goes here
    })
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The &lt;strong&gt;generate/middleware/default.json&lt;/strong&gt; file contains this JSON. The
&lt;strong&gt;config.type&lt;/strong&gt; is set to &lt;strong&gt;single&lt;/strong&gt; because it&amp;rsquo;s only generating one file. The
&lt;strong&gt;config.output&lt;/strong&gt; is the relative path where the file will be generated. Notice
that the &lt;strong&gt;config.output&lt;/strong&gt; also uses the &lt;strong&gt;package&lt;/strong&gt; variable. This is the
beauty of the &lt;code&gt;jay generate&lt;/code&gt; tool: the .json files are actually parsed
multiple times (limit is set to 100) to ensure all variables are set.&lt;/p&gt;

&lt;p&gt;In the first iteration of parsing, the &lt;strong&gt;package&lt;/strong&gt; key is set to value passed
via the command-line. In the second iteration of parsing, the &lt;strong&gt;{{.package}}&lt;/strong&gt;
variables are set to the same value because the top level &lt;strong&gt;package&lt;/strong&gt; key
becomes a variable itself.&lt;/p&gt;

&lt;p&gt;All first level keys (config.type, config.output, package) become variables
after the first iteration of parsing. If a variable is misspelled and is never
filled, a helpful error will display to the command-line.&lt;/p&gt;

&lt;p&gt;The folder structure of the templates (model, controller, etc) has no effect
on the generation, it&amp;rsquo;s purely to aid with organization of the template pairs.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
    &amp;quot;config.type&amp;quot;: &amp;quot;single&amp;quot;,
    &amp;quot;config.output&amp;quot;: &amp;quot;middleware/{{.package}}/{{.package}}.go&amp;quot;,
    &amp;quot;package&amp;quot;: &amp;quot;&amp;quot;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To generate this template, the command would look like this. The &lt;strong&gt;package&lt;/strong&gt;
key is separated from the value by a colon (:). An argument of &lt;code&gt;package:&lt;/code&gt;
without a value is also acceptable, but would end up creating a file called
&lt;strong&gt;.go&lt;/strong&gt; in the &lt;strong&gt;middleware&lt;/strong&gt; folder.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;jay generate middleware/default package:test
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The final output would be to the file, &lt;strong&gt;middleware/test/test.go&lt;/strong&gt;, and would
look like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package test
package test

import (
    &amp;quot;net/http&amp;quot;
)

// Handler
func Handler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Logic BEFORE the other handlers and function goes here
        next.ServeHTTP(w, r)
        // Logic AFTER the other handlers and function goes here
    })
}
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;controller-example&#34;&gt;Controller Example&lt;/h2&gt;

&lt;p&gt;This is a snippet of the template in &lt;strong&gt;generate/controller/bare.gen&lt;/strong&gt;. In this
template, there are two variables: &lt;strong&gt;package&lt;/strong&gt; and &lt;strong&gt;url&lt;/strong&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package {{.package}}
package {{.package}}

import (
    &amp;quot;net/http&amp;quot;

    &amp;quot;github.com/blue-jay/blueprint/controller/status&amp;quot;

    &amp;quot;github.com/blue-jay/core/router&amp;quot;
)

var (
    uri = &amp;quot;/{{.url}}&amp;quot;
)

// Load the routes.
func Load() {
    c := router.Chain()
    router.Get(uri, Index, c...)
    router.Get(uri+&amp;quot;/create&amp;quot;, Create, c...)
    router.Post(uri+&amp;quot;/create&amp;quot;, Store, c...)
    router.Get(uri+&amp;quot;/view/:id&amp;quot;, Show, c...)
    router.Get(uri+&amp;quot;/edit/:id&amp;quot;, Edit, c...)
    router.Patch(uri+&amp;quot;/edit/:id&amp;quot;, Update, c...)
    router.Delete(uri+&amp;quot;/:id&amp;quot;, Destroy, c...)
}

// Index displays the items.
func Index(w http.ResponseWriter, r *http.Request) {
    status.Error501(w, r)
}

// Create displays the create form.
func Create(w http.ResponseWriter, r *http.Request) {
    status.Error501(w, r)
}

...
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The &lt;strong&gt;generate/controller/bare.json&lt;/strong&gt; file contains this JSON.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
    &amp;quot;config.type&amp;quot;: &amp;quot;single&amp;quot;,
    &amp;quot;config.output&amp;quot;: &amp;quot;controller/{{.package}}/{{.package}}.go&amp;quot;,
    &amp;quot;package&amp;quot;: &amp;quot;&amp;quot;,
    &amp;quot;url&amp;quot;: &amp;quot;&amp;quot;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To generate this template, the command would look like this. Notice the second
variable, &lt;strong&gt;url&lt;/strong&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;jay generate controller/bare package:monkey url:banana
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The final output would be to the file, &lt;strong&gt;controller/monkey/monkey.go&lt;/strong&gt;, and
would look like this:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-go&#34;&gt;// Package monkey
package monkey

import (
    &amp;quot;net/http&amp;quot;

    &amp;quot;github.com/blue-jay/blueprint/controller/status&amp;quot;

    &amp;quot;github.com/blue-jay/core/router&amp;quot;
)

var (
    uri = &amp;quot;/banana&amp;quot;
)

// Load the routes.
func Load() {
    c := router.Chain()
    router.Get(uri, Index, c...)
    router.Get(uri+&amp;quot;/create&amp;quot;, Create, c...)
    router.Post(uri+&amp;quot;/create&amp;quot;, Store, c...)
    router.Get(uri+&amp;quot;/view/:id&amp;quot;, Show, c...)
    router.Get(uri+&amp;quot;/edit/:id&amp;quot;, Edit, c...)
    router.Patch(uri+&amp;quot;/edit/:id&amp;quot;, Update, c...)
    router.Delete(uri+&amp;quot;/:id&amp;quot;, Destroy, c...)
}

// Index displays the items.
func Index(w http.ResponseWriter, r *http.Request) {
    status.Error501(w, r)
}

// Create displays the create form.
func Create(w http.ResponseWriter, r *http.Request) {
    status.Error501(w, r)
}

...
&lt;/code&gt;&lt;/pre&gt;

&lt;h2 id=&#34;single-view-example&#34;&gt;Single View Example&lt;/h2&gt;

&lt;p&gt;The &lt;strong&gt;generate/view/single.gen&lt;/strong&gt; file contains this template. We don&amp;rsquo;t actually
want to parse this code because it&amp;rsquo;s a view itself. We can tell the parser
not to parse in the single.json file by setting the value of &lt;strong&gt;config.parse&lt;/strong&gt; to
&lt;strong&gt;false&lt;/strong&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;{{define &amp;quot;title&amp;quot;}}{{end}}
{{define &amp;quot;head&amp;quot;}}{{end}}
{{define &amp;quot;content&amp;quot;}}
    &amp;lt;div class=&amp;quot;page-header&amp;quot;&amp;gt;
        &amp;lt;h1&amp;gt;{{template &amp;quot;title&amp;quot; .}}&amp;lt;/h1&amp;gt;
    &amp;lt;/div&amp;gt;

    &amp;lt;p&amp;gt;Not Implemented&amp;lt;/p&amp;gt;

    {{template &amp;quot;footer&amp;quot; .}}
{{end}}
{{define &amp;quot;foot&amp;quot;}}{{end}}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The &lt;strong&gt;generate/view/single.json&lt;/strong&gt; file contains this JSON. Again, we set
&lt;strong&gt;config.parse&lt;/strong&gt; to false and only use the variables for specifying the
&lt;strong&gt;config.output&lt;/strong&gt; path. The variables are not used inside the single.json
template at all.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
    &amp;quot;config.type&amp;quot;: &amp;quot;single&amp;quot;,
    &amp;quot;config.output&amp;quot;: &amp;quot;view/{{.model}}/{{.name}}.tmpl&amp;quot;,
    &amp;quot;config.parse&amp;quot;: false,
    &amp;quot;model&amp;quot;: &amp;quot;&amp;quot;,
    &amp;quot;name&amp;quot;: &amp;quot;&amp;quot;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To generate this template, the command would look like this. Notice the second
variable, &lt;strong&gt;url&lt;/strong&gt;.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;jay generate view/single model:test name:create
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The final output would be to the file, &lt;strong&gt;view/test/create.tmpl&lt;/strong&gt;, and
would look like this - no difference from the template itself since it was not
parsed, just copied.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-html&#34;&gt;{{define &amp;quot;title&amp;quot;}}{{end}}
{{define &amp;quot;head&amp;quot;}}{{end}}
{{define &amp;quot;content&amp;quot;}}
    &amp;lt;div class=&amp;quot;page-header&amp;quot;&amp;gt;
        &amp;lt;h1&amp;gt;{{template &amp;quot;title&amp;quot; .}}&amp;lt;/h1&amp;gt;
    &amp;lt;/div&amp;gt;

    &amp;lt;p&amp;gt;Not Implemented&amp;lt;/p&amp;gt;

    {{template &amp;quot;footer&amp;quot; .}}
{{end}}
{{define &amp;quot;foot&amp;quot;}}{{end}}
&lt;/code&gt;&lt;/pre&gt;

&lt;h1 id=&#34;multiple-view-example&#34;&gt;Multiple View Example&lt;/h1&gt;

&lt;p&gt;The &lt;strong&gt;generate/view/default.json&lt;/strong&gt; file contains this JSON, but does not have
a matching default.gen file. This is because the .json file simply passes
variables to other .json files which have matching .gen files that generate
files. First, the &lt;strong&gt;config.type&lt;/strong&gt; key has a value of &lt;strong&gt;collection&lt;/strong&gt;, that&amp;rsquo;s how
you know it doesn&amp;rsquo;t have a matching .gen file. Next, the &lt;strong&gt;config.collection&lt;/strong&gt;
key contains an array of items that specify which template pairs to pass
variables to.&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;model&lt;/strong&gt; key under each template receives the &lt;strong&gt;model&lt;/strong&gt; variable from the
root of the package which is required from the command-line.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
    &amp;quot;config.type&amp;quot;: &amp;quot;collection&amp;quot;,
    &amp;quot;config.collection&amp;quot;: [
        {
            &amp;quot;view/create&amp;quot;: {
                &amp;quot;model&amp;quot;: &amp;quot;{{.model}}&amp;quot;
            }
        },
        {
            &amp;quot;view/edit&amp;quot;: {
                &amp;quot;model&amp;quot;: &amp;quot;{{.model}}&amp;quot;
            }
        },
        {
            &amp;quot;view/index&amp;quot;: {
                &amp;quot;model&amp;quot;: &amp;quot;{{.model}}&amp;quot;
            }
        },
        {
            &amp;quot;view/show&amp;quot;: {
                &amp;quot;model&amp;quot;: &amp;quot;{{.model}}&amp;quot;
            }
        }
    ],
    &amp;quot;model&amp;quot;: &amp;quot;&amp;quot;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;In this example, the default.json file will pass variables to the following
files:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;generate/view/create.json&lt;/li&gt;
&lt;li&gt;generate/view/edit.json&lt;/li&gt;
&lt;li&gt;generate/view/index.json&lt;/li&gt;
&lt;li&gt;generate/view/show.json&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The files are all still relative to the root &lt;strong&gt;generate&lt;/strong&gt; folder. Also, if you
look at each of the four files, you&amp;rsquo;ll see that they require only one variable:
&lt;strong&gt;model&lt;/strong&gt;. Here is the contents of &lt;strong&gt;generate/view/create.json&lt;/strong&gt;:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
    &amp;quot;config.type&amp;quot;: &amp;quot;single&amp;quot;,
    &amp;quot;config.output&amp;quot;: &amp;quot;view/{{.model}}/create.tmpl&amp;quot;,
    &amp;quot;config.parse&amp;quot;: false,
    &amp;quot;model&amp;quot;: &amp;quot;&amp;quot;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To generate all four of these templates, the command would look like this.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;jay generate view/default model:test
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;The final output would be to the following files:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;view/test/create.json&lt;/li&gt;
&lt;li&gt;view/test/edit.json&lt;/li&gt;
&lt;li&gt;view/test/index.json&lt;/li&gt;
&lt;li&gt;view/test/show.json&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&#34;crud-example&#34;&gt;CRUD Example&lt;/h2&gt;

&lt;p&gt;If you put all those piece above together, you can generate the controller,
model, and all four views necessary for a working CRUD component in a single
command.&lt;/p&gt;

&lt;p&gt;The &lt;strong&gt;generate/crud/default.json&lt;/strong&gt; file contains this JSON:&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-json&#34;&gt;{
    &amp;quot;config.type&amp;quot;: &amp;quot;collection&amp;quot;,
    &amp;quot;config.collection&amp;quot;: [
        {
            &amp;quot;model/default&amp;quot;: {
                &amp;quot;package&amp;quot;: &amp;quot;{{.model}}&amp;quot;,
                &amp;quot;table&amp;quot;: &amp;quot;{{.model}}&amp;quot;
            }
        },
        {
            &amp;quot;controller/default&amp;quot;: {
                &amp;quot;package&amp;quot;: &amp;quot;{{.controller}}&amp;quot;,
                &amp;quot;url&amp;quot;: &amp;quot;{{.controller}}&amp;quot;,
                &amp;quot;model&amp;quot;: &amp;quot;{{.model}}&amp;quot;,
                &amp;quot;view&amp;quot;: &amp;quot;{{.view}}&amp;quot;
            }
        },
        {
            &amp;quot;view/default&amp;quot;: {
                &amp;quot;model&amp;quot;: &amp;quot;{{.view}}&amp;quot;
            }
        }
    ],
    &amp;quot;model&amp;quot;: &amp;quot;&amp;quot;,
    &amp;quot;controller&amp;quot;: &amp;quot;&amp;quot;,
    &amp;quot;view&amp;quot;: &amp;quot;&amp;quot;
}
&lt;/code&gt;&lt;/pre&gt;

&lt;p&gt;To generate all the components, the command would look like this.&lt;/p&gt;

&lt;pre&gt;&lt;code class=&#34;language-bash&#34;&gt;jay generate crud/default model:note controller:notepad view:note
&lt;/code&gt;&lt;/pre&gt;
</description>
    </item>
    
  </channel>
</rss>