accessibleProperties([ properties ]) <!--- In `models/User.cfc`, only `isActive` can be set through mass assignment operations like `updateAll()` --->
<cffunction name="init">
    <cfset accessibleProperties("isActive")>
</cffunction>

<!--- Adds the default routes to your application (done in `config/routes.cfm`) --->
<cfset addDefaultRoutes()>

addError(property, message [, name ]) <!--- Add an error to the `email` property --->
<cfset this.addError(property="email", message="Sorry, you are not allowed to use that email. Try again, please.")>

Adds an error on the object as a whole (not related to any specific property). <!--- Add an error on the object --->
<cfset this.addErrorToBase(message="Your email address must be the same as your domain name.")>

<!--- Add the `js` format --->
<cfset addFormat(extension="js", mimeType="text/javascript")>

<!--- Add the `ppt` and `pptx` formats --->
<cfset addFormat(extension="ppt", mimeType="application/vnd.ms-powerpoint")>
<cfset addFormat(extension="pptx", mimeType="application/vnd.ms-powerpoint")>

<!--- Example 1: Adds a route which will invoke the `profile` action on the `user` controller with `params.userName` set when the URL matches the `pattern` argument --->
<cfset addRoute(name="userProfile", pattern="user/[username]", controller="user", action="profile")>

<!--- Example 2: Category/product URLs. Note the order of precedence is such that the more specific route should be defined first so Wheels will fall back to the less-specific version if it's not found --->
<cfset addRoute(name="product", pattern="products/[categorySlug]/[productSlug]", controller="products", action="product")>
<cfset addRoute(name="productCategory", pattern="products/[categorySlug]", controller="products", action="category")>
<cfset addRoute(name="products", pattern="products", controller="products", action="index")>

<!--- Example 3: Change the `home` route. This should be listed last because it is least specific --->
<cfset addRoute(name="home", pattern="", controller="main", action="index")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterCreate("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterDelete("fixObj")>

<!--- Instruct CFWheels to call the `setTime` method after getting objects or records with one of the finder methods --->
<cffunction name="init">
	<cfset afterFind("setTime")>
</cffunction>

<cffunction name="setTime">
	<cfset arguments.fetchedAt = Now()>
	<cfreturn arguments>
</cffunction>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterInitialization("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterNew("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterSave("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterUpdate("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterValidation("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterValidationOnCreate("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset afterValidationOnUpdate("fixObj")>

allChanges() <!--- Get an object, change it, and then ask for its changes (will return a struct containing the changes, both property names and their values) --->
<cfset member = model("member").findByKey(params.memberId)>
<cfset member.firstName = params.newFirstName>
<cfset member.email = params.newEmail>
<cfset allChanges = member.allChanges()>

allErrors() <!--- Get all the errors for the `user` object --->
<cfset errorInfo = user.allErrors()> <!--- Sample Return of Function --->
[
	{
  	message:'Username must not be blank',
    name:'usernameError',
    property:'username'
  },
  {
  	message:'Password must not be blank',
    name:'passwordError',
    property:'password'
  }
]

#autoLink("Download CFWheels from http://cfwheels.org/download")#
-> Download CFWheels from <a href="http://cfwheels.org/download">http://cfwheels.org/download</a>

#autoLink("Email us at [email protected]")#
-> Email us at <a href="mailto:[email protected]">[email protected]</a>

// In `models/User.cfc`, disable automatic validations. In this case, automatic validations are probably enabled globally, but we want to disable just for this model.
<cffunction name="init">
	<cfscript>
		automaticValidations(false);
	</cfscript>
</cffunction>

// Get the average salary for all employees
avgSalary = model("employee").average("salary");

// Get the average salary for employees in a given department
avgSalary = model("employee").average(property="salary", where="departmentId=##params.key##");

// Make sure a numeric value is always returned if no records are calculated
avgSalary = model("employee").average(property="salary", where="salary BETWEEN ##params.min## AND ##params.max##", ifNull=0);

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset beforeCreate("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset beforeDelete("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset beforeSave("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset beforeUpdate("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset beforeValidation("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset beforeValidationOnCreate("fixObj")>

<!--- Instruct CFWheels to call the `fixObj` method --->
<cfset beforeValidationOnUpdate("fixObj")>

// Specify that instances of this model belong to an author. (The table for this model should have a foreign key set on it, typically named `authorid`.)
belongsTo("author");

// Same as above, but because we have broken away from the foreign key naming convention, we need to set `modelName` and `foreignKey`
belongsTo(name="bookWriter", modelName="author", foreignKey="authorId");

<!--- view code --->
<cfoutput>
    #startFormTag(action="something")#
        <!--- form controls go here --->
        #buttonTag(content="Submit this form", value="save")#
    #endFormTag()#
</cfoutput>

#buttonTo(text="Delete Account", action="perFormDelete", disable="Wait...")#

// apply attributes to the input element by prefixing any arguments with "input"
#buttonTo(text="Edit", action="edit", inputId="edit-button", inputClass="edit-button-class")#

// Cache the `termsOfUse` action
caches("termsOfUse");

// Cache the `termsOfUse` action for 30 minutes
caches(actions="browseByUser,browseByTitle", time=30);

// Cache the `termsOfUse` and `codeOfConduct` actions, including their filters
caches(actions="termsOfUse,codeOfConduct", static=true);

// Cache content separately based on region
caches(action="home", key="request.region");

capitalize(text) <!--- Capitalize a sentence, will result in "Wheels is a framework" --->
#capitalize("wheels is a framework")#

changedFrom(property) <!--- Get a member object and change the `email` property on it --->
<cfset member = model("member").findByKey(params.memberId)>
<cfset member.email = params.newEmail>

<!--- Get the previous value (what the `email` property was before it was changed)--->
<cfset oldValue = member.changedFrom("email")>

<!--- The above can also be done using a dynamic function like this --->
<cfset oldValue = member.emailChangedFrom()>

changedProperties() <!--- Get an object, change it, and then ask for its changes (will return a list of the property names that have changed, not the values themselves) --->
<cfset member = model("member").findByKey(params.memberId)>
<cfset member.firstName = params.newFirstName>
<cfset member.email = params.newEmail>
<cfset changedProperties = member.changedProperties()>

checkBox(objectName, property [, association, position, checkedValue, uncheckedValue, label, labelPlacement, prepend, append, prependToLabel, appendToLabel, errorElement, errorClass ]) <!--- Basic example of a check box for a boolean field --->
<cfoutput>
    #checkBox(objectName="photo", property="isPublic", label="Display this photo publicly.")#
</cfoutput>

<!--- Shows check boxes for selecting public access for all photos provided by the `photos` association and nested properties --->
<cfoutput>
    <cfloop from="1" to="#ArrayLen(user.photos)#" index="i">
        <div>
            <h3>#user.photos[i].title#:</h3>
            <div>
                #checkBox(objectName="user", association="photos", position=i, property="isPublic", label="Display this photo publicly.")#
            </div>
        </div>
    </cfloop>
</cfoutput>

<!--- Example 1: Basic usage involves a `label`, `name`, and `value` --->
<cfoutput>
    #checkBoxTag(name="subscribe", value="true", label="Subscribe to our newsletter", checked=false)#
</cfoutput>

<!--- Example 2: Loop over a query to display choices and whether or not they are checked --->
<!--- - Controller code --->
<cfset pizza = model("pizza").findByKey(session.pizzaId)>
<cfset selectedToppings = pizza.toppings()>
<cfset toppings = model("topping").findAll(order="name")>

<!--- View code --->
<fieldset>
	<legend>Toppings</legend>
	<cfoutput query="toppings">
		#checkBoxTag(name="toppings", value="true", label=toppings.name, checked=YesNoFormat(ListFind(ValueList(selectedToppings.id), toppings.id))#
	</cfoutput>
</fieldset>

// Convert startTime to UTC (maybe done in an "after find" call back) but then tell CFWheels to clear the information about this change (but not the change itself) so that it won't attempt to save the new value to the database, report it as being changed when calling hasChanged() etc.

this.startTime = DateConvert("Local2UTC", this.startTime);
this.clearChangeInformation(property="startTime");

// Clear information for all properties
this.clearChangeInformation();

clearErrors([ property, name ]) <!--- Clear all errors on the object as a whole --->
<cfset this.clearErrors()>

<!--- Clear all errors on `firstName` --->
<cfset this.clearErrors("firstName")>

columnDataForProperty(property) <!--- Get an object, set a value and then see if the property exists --->
<cfset employee = model("employee").new()>
<cfset employee.columnDataForProperty("firstName")><!--- returns column struct --->

columnForProperty(property) <!--- Get an object, set a value and then see if the property exists --->
<cfset employee = model("employee").new()>
<cfset employee.columnForProperty("firstName")><!--- returns column name, in this case "firstname" if the convention is used --->

columnNames() <!--- Get a list of all the column names in the table mapped to the `author` model --->
<cfset columns = model("author").columnNames()>

columns() <!--- Get the columns names in the order they are in the database --->
<cfset employee = model("employee").columns()>

compareTo() <!--- Load a user requested in the URL/form and restrict access if it doesn't match the user stored in the session --->
<cfset user = model("user").findByKey(params.key)>
<cfif not user.compareTo(session.user)>
    <cfset renderPage(action="accessDenied")>
</cfif>

<!--- In your view --->
<cfsavecontent variable="mySidebar">
<h1>My Sidebar Text</h1>
</cfsavecontent>
<cfset contentFor(sidebar=mySidebar)>

<!--- In your layout --->
<html>
<head>
    <title>My Site</title>
</head>
<body>

<cfoutput>
#includeContent("sidebar")#

#includeContent()#
</cfoutput>

</body>
</html>

<!--- In `views/layout.cfm` --->
<cfoutput>##contentForLayout()##</cfoutput>

controller(name [, params ]) <cfset testController = controller("users", params)>

// Count how many authors there are in the table
authorCount = model("author").count();

// Count how many authors that have a last name starting with an "A"
authorOnACount = model("author").count(where="lastName LIKE ''A%''");

// Count how many authors that have written books starting with an "A"
authorWithBooksOnACount = model("author").count(include="books", where="booktitle LIKE ''A%''");

// Count the number of comments on a specific post (a `hasMany` association from `post` to `comment` is required)
// The `commentCount` method will call `model("comment").count(where="postId=##post.id##")` internally
aPost = model("post").findByKey(params.postId);
amount = aPost.commentCount();

<!--- Create a new author and save it to the database --->
<cfset newAuthor = model("author").create(params.author)>

<!--- Same as above using named arguments --->
<cfset newAuthor = model("author").create(firstName="John", lastName="Doe")>

<!--- Same as above using both named arguments and a struct --->
<cfset newAuthor = model("author").create(active=1, properties=params.author)>

<!--- If you have a `hasOne` or `hasMany` association setup from `customer` to `order`, you can do a scoped call. (The `createOrder` method below will call `model("order").create(customerId=aCustomer.id, shipping=params.shipping)` internally.) --->
<cfset aCustomer = model("customer").findByKey(params.customerId)>
<cfset anOrder = aCustomer.createOrder(shipping=params.shipping)>

<!--- Alternating table row colors --->
<table>
	<thead>
		<tr>
			<th>Name</th>
			<th>Phone</th>
		</tr>
	</thead>
	<tbody>
		<cfoutput query="employees">
			<tr class="##cycle("odd,even")##">
				<td>##employees.name##</td>
				<td>##employees.phone##</td>
			</tr>
		</cfoutput>
	</tbody>
</table>

<!--- Alternating row colors and shrinking emphasis --->
<cfoutput query="employees" group="departmentId">
	<div class="##cycle(values="even,odd", name="row")##">
		<ul>
			<cfoutput>
				<cfset rank = cycle(values="president,vice-president,director,manager,specialist,intern", name="position")>
				<li class="##rank##">##categories.categoryName##</li>
				<cfset resetCycle("emphasis")>
			</cfoutput>
		</ul>
	</div>
</cfoutput>

dataSource(datasource [, username, password ]) <!--- In models/User.cfc --->
<cffunction name="init">
    <!--- Tell Wheels to use the data source named `users_source` instead of the default one whenever this model makes SQL calls  --->
              <cfset dataSource("users_source")>
</cffunction>

dateSelect([ objectName, property, association, position, order, separator, startYear, endYear, monthDisplay, includeBlank, label, labelPlacement, prepend, append, prependToLabel, appendToLabel, errorElement, errorClass, combine ]) <!--- View code --->
<cfoutput>
    #dateSelect(objectName="user", property="dateOfBirth")#
</cfoutput>

<!--- Show fields to select month and year --->
<cfoutput>
    #dateSelect(objectName="order", property="expirationDate", order="month,year")#
</cfoutput>

<!--- This "Tag" version of function accepts `name` and `selected` instead of binding to a model object --->
<cfoutput>
	#dateSelectTags(name="dateStart", selected=params.dateStart)#
</cfoutput>

<!--- Show fields for month and year only --->
<cfoutput>
	#dateSelectTags(name="expiration", selected=params.expiration, order="month,year")#
</cfoutput>

dateTimeSelect(objectName, property [, association, position, dateOrder, dateSeparator, startYear, endYear, monthDisplay, timeOrder, timeSeparator, minuteStep, secondStep, separator, includeBlank, label, labelPlacement, prepend, append, prependToLabel, appendToLabel, errorElement, errorClass, combine, twelveHour ]) <!--- View code --->
<cfoutput>
    #dateTimeSelect(objectName="article", property="publishedAt")#
</cfoutput>

<!--- Show fields for month, day, hour, and minute --->
<cfoutput>
    #dateTimeSelect(objectName="appointment", property="dateTimeStart", dateOrder="month,day", timeOrder="hour,minute")#
</cfoutput>

<!--- This "Tag&qquot; version of the function accepts a `name` and `selected` instead of binding to a model object --->
<cfoutput>
    #dateTimeSelectTags(name="dateTimeStart", selected=params.dateTimeStart)#
</cfoutput>

<!--- Show fields for month, day, hour, and minute --->
<cfoutput>
	#dateTimeSelectTags(name="dateTimeStart", selected=params.dateTimeStart, dateOrder="month,day", timeOrder="hour,minute")#
</cfoutput>

<!--- This "Tag" version of the function accepts a `name` and `selected` instead of binding to a model object --->
<cfoutput>
    #daySelectTag(name="dayOfWeek", selected=params.dayOfWeek)#
</cfoutput>

delete([ parameterize, transaction, callbacks, includeSoftDeletes, softDelete ]) <!--- Get a post object and then delete it from the database --->
<cfset post = model("post").findByKey(33)>
<cfset post.delete()>

<!--- If you have a `hasMany` association setup from `post` to `comment`, you can do a scoped call. (The `deleteComment` method below will call `comment.delete()` internally.) --->
<cfset post = model("post").findByKey(params.postId)>
<cfset comment = model("comment").findByKey(params.commentId)>
<cfset post.deleteComment(comment)>

deleteAll([ where, include, reload, parameterize, instantiate, transaction, callbacks, includeSoftDeletes, softDelete ]) <!--- Delete all inactive users without instantiating them (will skip validation and callbacks) --->
<cfset recordsDeleted = model("user").deleteAll(where="inactive=1", instantiate=false)>

<!--- If you have a `hasMany` association setup from `post` to `comment`, you can do a scoped call. (The `deleteAllComments` method below will call `model("comment").deleteAll(where="postId=#post.id#")` internally.) --->
<cfset post = model("post").findByKey(params.postId)>
<cfset howManyDeleted = post.deleteAllComments()>

deleteByKey(key [, reload, transaction, callbacks, includeSoftDeletes, softDelete ]) <!--- Delete the user with the primary key value of `1` --->
<cfset result = model("user").deleteByKey(1)>

deleteOne([ where, order, reload, transaction, callbacks, includeSoftDeletes, softDelete ]) <!--- Delete the user that signed up last --->
<cfset result = model("user").deleteOne(order="signupDate DESC")>

<!--- If you have a `hasOne` association setup from `user` to `profile` you can do a scoped call (the `deleteProfile` method below will call `model("profile").deleteOne(where="userId=#aUser.id#")` internally) --->
<cfset aUser = model("user").findByKey(params.userId)>
<cfset aUser.deleteProfile()>

deobfuscateParam(param) <!--- Get the original value from an obfuscated one --->
<cfset originalValue = deobfuscateParam("b7ab9a50")>

distanceOfTimeInWords(fromTime, toTime [, includeSeconds ]) <cfset aWhileAgo = Now() - 30>
<cfset rightNow = Now()>
<cfoutput>#distanceOfTimeInWords(aWhileAgo, rightNow)#</cfoutput>

<!--- view code --->
		<cfoutput>
		    #startFormTag(action="create")#
		        <!--- your form controls --->
		    #endFormTag()#
		</cfoutput>

errorCount([ property, name ]) <!--- Check how many errors are set on the object --->
<cfif author.errorCount() GTE 10>
    <!--- Do something to deal with this very erroneous author here... --->
</cfif>

<!--- Check how many errors are associated with the `email` property --->
<cfif author.errorCount("email") gt 0>
    <!--- Do something to deal with this erroneous author here... --->
</cfif>

errorMessageOn(objectName, property [, prependText, appendText, wrapperElement, class ]) <!--- view code --->
<cfoutput>
  #errorMessageOn(objectName="user", property="email")#
</cfoutput>

errorMessagesFor(objectName [, class, showDuplicates ]) <!--- view code --->
<cfoutput>
    #errorMessagesFor(objectName="user")#
</cfoutput>

errorsOn(property [, name ]) <!--- Get all errors related to the email address of the user object ---> <cfset errors = user.errorsOn("emailAddress")>

errorsOnBase([ name ]) <!--- Get all general type errors for the user object --->
<cfset errors = user.errorsOnBase()>

#excerpt(text="ColdFusion CFWheels is a Rails-like MVC framework for Adobe ColdFusion, Railo and Lucee", phrase="framework", radius=5)#
-> ... MVC framework for ...

// Checking if Joe exists in the database
result = model("user").exists(where="firstName = 'Joe'");

// Checking if a specific user exists based on a primary key valued passed in through the URL/form in an if statement
if (model("user").exists(keyparams.key))
{
	// Do something
}

// If you have a `belongsTo` association setup from `comment` to `post`, you can do a scoped call. (The `hasPost` method below will call `model("post").exists(comment.postId)` internally.)
comment = model("comment").findByKey(params.commentId);
commentHasAPost = comment.hasPost();

// If you have a `hasOne` association setup from `user` to `profile`, you can do a scoped call. (The `hasProfile` method below will call `model("profile").exists(where="userId=#user.id#")` internally.)
user = model("user").findByKey(params.userId);
userHasProfile = user.hasProfile();

// If you have a `hasMany` association setup from `post` to `comment`, you can do a scoped call. (The `hasComments` method below will call `model("comment").exists(where="postid=#post.id#")` internally.)
post = model("post").findByKey(params.postId);
postHasComments = post.hasComments();

<!--- Provide a `label` and the required `objectName` and `property` --->
<cfoutput>
    #fileField(label="Photo", objectName="photo", property="imageFile")#
</cfoutput>

<!--- Display fields for photos provided by the `screenshots` association and nested properties --->
<fieldset>
	<legend>Screenshots</legend>
	<cfloop from="1" to="##ArrayLen(site.screenshots)##" index="i">
		#fileField(label="File ####i##", objectName="site", association="screenshots", position=i, property="file")#
		#textField(label="Caption ####i##", objectName="site", association="screenshots", position=i, property="caption")#
	</cfloop>
</fieldset>

<!--- Basic usage usually involves a `label`, `name`, and `value` --->
<cfoutput>
    #fileFieldTag(label="Photo", name="photo", value=params.photo)#
</cfoutput>

// Get filter chain
myFilterChain = filterChain();

// Get filter chain for after filters only
myFilterChain = filterChain(type="after");

// Always execute `restrictAccess` before all actions in this controller
filters("restrictAccess");

// Always execute `isLoggedIn` and `checkIPAddress` (in that order) before all actions in this controller, except the `home` and `login` actions
filters(through="isLoggedIn,checkIPAddress", except="home,login");

<!--- Getting only 5 users and ordering them randomly ---> <cfset fiveRandomUsers = model("user").findAll(maxRows=5, order="random")> <!--- Including an association (which in this case needs to be setup as a `belongsTo` association to `author` on the `article` model first) ---> <cfset articles = model("article").findAll( include="author", where="published=1", order="createdAt DESC" )> <!--- Similar to the above but using the association in the opposite direction (which needs to be setup as a `hasMany` association to `article` on the `author` model) ---> <cfset bobsArticles = model("author").findAll( include="articles", where="firstName='Bob'" )> <!--- Using pagination (getting records 26-50 in this case) and a more complex way to include associations (a song `belongsTo` an album, which in turn `belongsTo` an artist) ---> <cfset songs = model("song").findAll( include="album(artist)", page=2, perPage=25 )> <!--- Using a dynamic finder to get all books released a certain year. Same as calling model("book").findOne(where="releaseYear=#params.year#") ---> <cfset books = model("book").findAllByReleaseYear(params.year)> <!--- Getting all books of a certain type from a specific year by using a dynamic finder. Same as calling model("book").findAll( where="releaseYear=#params.year# AND type='#params.type#'" ) ---> <cfset books = model("book").findAllByReleaseYearAndType( "#params.year#,#params.type#" )> <!--- If you have a `hasMany` association setup from `post` to `comment`, you can do a scoped call. (The `comments` method below will call `model("comment").findAll(where="postId=#post.id#")` internally) ---> <cfset post = model("post").findByKey(params.postId)> <cfset comments = post.comments()>

// basic usage
primaryKeyList = model("artist").findAllKeys();

// Quote values, use a different delimiter and filter results with the "where" argument
primaryKeyList = model("artist").findAllKeys(quoted=true, delimiter="-", where="active=1");

<!--- Getting the author with the primary key value `99` as an object --->
<cfset auth = model("author").findByKey(99)>

<!--- Getting an author based on a form/URL value and then checking if it was found --->
<cfset auth = model("author").findByKey(params.key)>
<cfif NOT IsObject(auth)>
    <cfset flashInsert(message="Author #params.key# was not found")>
    <cfset redirectTo(back=true)>
</cfif>

<!--- If you have a `belongsTo` association setup from `comment` to `post`, you can do a scoped call. (The `post` method below will call `model("post").findByKey(comment.postId)` internally) --->
<cfset comment = model("comment").findByKey(params.commentId)>
<cfset post = comment.post()>

findOne([ where, order, select, include, cache, reload, parameterize, returnAs, includeSoftDeletes ]) <!--- Getting the most recent order as an object from the database --->
<cfset order = model("order").findOne(order="datePurchased DESC")>

<!--- Using a dynamic finder to get the first person with the last name `Smith`. Same as calling `model("user").findOne(where"lastName='Smith'")` --->
<cfset person = model("user").findOneByLastName("Smith")>

<!--- Getting a specific user using a dynamic finder. Same as calling `model("user").findOne(where"email='[email protected]' AND password='mypass'")` --->
<cfset user = model("user").findOneByEmailAndPassword("[email protected],mypass")>

<!--- If you have a `hasOne` association setup from `user` to `profile`, you can do a scoped call. (The `profile` method below will call `model("profile").findOne(where="userId=#user.id#")` internally) --->
<cfset user = model("user").findByKey(params.userId)>
<cfset profile = user.profile()>

<!--- If you have a `hasMany` association setup from `post` to `comment`, you can do a scoped call. (The `findOneComment` method below will call `model("comment").findOne(where="postId=#post.id#")` internally) --->
<cfset post = model("post").findByKey(params.postId)>
<cfset comment = post.findOneComment(where="text='I Love Wheels!'")>

// Return the first object that matches "Timberlake" in the last name column. If there is no match, create a new one and set firstName to "Justin".
newArtist = model("artist").findOrCreateByLastName(lastName="Timberlake", firstName="Justin");

// Get the current value of notice in the Flash
notice = flash("notice");

// Get the entire Flash as a struct
flashContents = flash();

flashClear();

count = flashCount();

flashDelete(key="errorMessage");

flashInsert(msg="It Worked!");

empty = flashIsEmpty();

// Keep the entire Flash for the next request
flashKeep();

// Keep the "error" key in the Flash for the next request
flashKeep("error");

// Keep both the "error" and "success" keys in the Flash for the next request
flashKeep("error,success");

errorExists = flashKeyExists("error");

<!--- In the controller action --->
flashInsert(success="Your post was successfully submitted.");
flashInsert(alert="Don''t forget to tweet about this post!");
flashInsert(error="This is an error message.");

<!--- In the layout or view --->
<cfoutput>
	#flashMessages()#
</cfoutput>
<!---
	Generates this (sorted alphabetically):
	<div class="flashMessages">
		<p class="alertMessage">
			Don''t forget to tweet about this post!
		</p>
		<p class="errorMessage">
			This is an error message.
		</p>
		<p class="successMessage">
			Your post was successfully submitted.
		</p>
	</div>
--->

<!--- Only show the "success" key in the view --->
<cfoutput>
	#flashMessages(key="success")#
</cfoutput>
<!---
	Generates this:
	<div class="flashMessage">
		<p class="successMessage">
			Your post was successfully submitted.
		</p>
	</div>
--->

<!--- Show only the "success" and "alert" keys in the view, in that order --->
<cfoutput>
	#flashMessages(keys="success,alert")#
</cfoutput>
<!---
	Generates this (sorted alphabetically):
	<div class="flashMessages">
		<p class="successMessage">
			Your post was successfully submitted.
		</p>
		<p class="alertMessage">
			Don''t forget to tweet about this post!
		</p>
	</div>
--->

get(name [, functionName ]) <!--- Get the current value for the `tableNamePrefix` Wheels setting --->
<cfset setting = get("tableNamePrefix")>

<!--- Get the default for the `message` argument of the `validatesConfirmationOf` method  --->
<cfset setting = get(functionName="validatesConfirmationOf", name="message")>

getTableNamePrefix() <!--- Get the table name prefix for this user when running a custom query --->
<cffunction name="getDisabledUsers" returntype="query">
    <cfset var loc = {}>
    <cfquery datasource="#get('dataSourceName')#" name="loc.disabledUsers">
        SELECT
            *
        FROM
            #this.getTableNamePrefix()#users
        WHERE
            disabled = 1
    </cfquery>
    <cfreturn loc.disabledUsers>
</cffunction>

hasChanged([ property ]) <!--- Get a member object and change the `email` property on it --->
<cfset member = model("member").findByKey(params.memberId)>
<cfset member.email = params.newEmail>

<!--- Check if the `email` property has changed --->
<cfif member.hasChanged("email")>
    <!--- Do something... --->
</cfif>

<!--- The above can also be done using a dynamic function like this --->
<cfif member.emailHasChanged()>
    <!--- Do something... --->
</cfif>

hasErrors([ property, name ]) <!--- Check if the post object has any errors set on it --->
<cfif post.hasErrors()>
    <!--- Send user to a form to correct the errors... --->
</cfif>

// Specify that instances of this model has many comments (the table for the associated model, not the current, should have the foreign key set on it).
hasMany("comments");

// Specify that this model (let''s call it `reader` in this case) has many subscriptions and setup a shortcut to the `publication` model (useful when dealing with many-to-many relationships).
hasMany(name="subscriptions", shortcut="publications");

// Automatically delete all associated `comments` whenever this object is deleted
hasMany(name="comments", dependent="deleteAll");

// When not following CFWheels naming conventions for associations, it can get complex to define how a `shortcut` works.
// In this example, we are naming our `shortcut` differently than the actual model''s name.

// In the models/Customer.cfc `init()` method
hasMany(name="subscriptions", shortcut="magazines", through="publication,subscriptions");

// In the models/Subscription.cfc `init()` method
belongsTo("customer");
belongsTo("publication");

// In the models/Publication `init()` method
hasMany("subscriptions");

hasManyCheckBox(objectName, association, keys [, label, labelPlacement, prepend, append, prependToLabel, appendToLabel, errorElement, errorClass ]) <!--- Show check boxes for associating authors with the current book --->
<cfloop query="authors">
    #hasManyCheckBox(
        label=authors.fullName,
        objectName="book",
        association="bookAuthors",
        keys="#book.key()#,#authors.id#"
    )#
</cfloop>

hasManyRadioButton(objectName, association, property, keys, tagValue [, checkIfBlank, label ]) <!--- Show radio buttons for associating a default address with the current author --->
<cfloop query="addresses">
    #hasManyRadioButton(
        label=addresses.title,
        objectName="author",
        association="authorsDefaultAddresses",
        keys="#author.key()#,#addresses.id#"
    )#
</cfloop>

// Specify that instances of this model has one profile. (The table for the associated model, not the current, should have the foreign key set on it.)
hasOne("profile");

// Same as above but setting the `joinType` to `inner`, which basically means this model should always have a record in the `profiles` table
hasOne(name="profile", joinType="inner");

// Automatically delete the associated `profile` whenever this object is deleted
hasMany(name="comments", dependent="delete");

hasProperty(property) <!--- Get an object, set a value and then see if the property exists --->
<cfset employee = model("employee").new()>
<cfset employee.firstName = "dude">
<cfset employee.hasProperty("firstName")><!--- returns true --->

<!--- This is also a dynamic method that you could do --->
<cfset employee.hasFirstName()>

<!--- Provide an `objectName` and `property` --->
<cfoutput>
    #hiddenField(objectName="user", property="id")#
</cfoutput>

<!--- Basic usage usually involves a `name` and `value` --->
<cfoutput>
    #hiddenFieldTag(name="userId", value=user.id)#
</cfoutput>

#highlight(text="You searched for: Wheels", phrases="Wheels")#
-> You searched for: <span class="highlight">Wheels</span>

<!--- This "Tag" version of the function accepts a `name` and `selected` instead of binding to a model object --->
<cfoutput>
    #hourSelectTag(name="hourOfMeeting", selected=params.hourOfMeeting)#
</cfoutput>

<!--- Show 12 hours instead of 24 --->
<cfoutput>
	#hourSelectTag(name="hourOfMeeting", selected=params.hourOfMeeting, twelveHour=true)#
</cfoutput>

humanize(text [, except ]) <!--- Humanize a string, will result in "Wheels Is A Framework" --->
#humanize("wheelsIsAFramework")#

<!--- Humanize a string, force wheels to replace "Cfml" with "CFML" --->
#humanize("wheelsIsACFMLFramework", "CFML")#

hyphenize(string) <!--- Outputs "my-blog-post" --->
<cfoutput>
    #hyphenize("myBlogPost")#
</cfoutput>

imageTag(source) <!--- Outputs an `img` tag for `images/logo.png` --->
#imageTag("logo.png")#

<!--- Outputs an `img` tag for `http://cfwheels.org/images/logo.png` --->
#imageTag(source="http://cfwheels.org/images/logo.png", alt="ColdFusion on Wheels")#

<!--- Outputs an `img` tag with the `class` attribute set --->
#imageTag(source="logo.png", class="logo")#

<!--- In your view template, let''s say `views/blog/post.cfm --->
<cfset contentFor(head=''<meta name="robots" content="noindex,nofollow">"'')>
<cfset contentFor(head=''<meta name="author" content="[email protected]"'')>

<!--- In `views/layout.cfm` --->
<html>
	<head>
	    <title>My Site</title>
	    ##includeContent("head")##
	</head>
	<body>
		<cfoutput>
			##includeContent()##
		</cfoutput>
	</body>
</html>

includedInObject(objectName, association, keys) <!--- Check to see if the customer is subscribed to the Swimsuit Edition. Note that the order of the `keys` argument should match the order of the `customerid` and `publicationid` columns in the `subscriptions` join table --->
<cfif not includedInObject(objectName="customer", association="subscriptions", keys="#customer.key()#,#swimsuitEdition.id#")>
    <cfset assignSalesman(customer)>
</cfif>

<!--- Make sure that the `sidebar` value is provided for the parent layout --->
<cfsavecontent variable="categoriesSidebar">
	<cfoutput>
		<ul>
			##includePartial(categories)##
		</ul>
	</cfoutput>
</cfsavecontent>
<cfset contentFor(sidebar=categoriesSidebar)>

<!--- Include parent layout at `views/layout.cfm` --->
<cfoutput>
	##includeLayout("/layout.cfm")##
</cfoutput>

<cfoutput> <!--- If we're in the "sessions" controller, CFWheels will include the file "views/sessions/_login.cfm". ---> #includePartial("login")# <!--- CFWheels will include the file "views/shared/_button.cfm". ---> #includePartial(partial="/shared/button")# <!--- If we're in the "posts" controller and the "posts" variable includes a query result set, CFWheels will loop through the record set and include the file "views/posts/_post.cfm" for each record. ---> <cfset posts = model("post").findAll()> #includePartial(posts)# <!--- We can also override the template file loaded for the example above. ---> #includePartial(partial="/shared/post", query=posts)# <!--- The same works when passing a model instance. ---> <cfset post = model("post").findByKey(params.key)> #includePartial(post)# #includePartial(partial="/shared/post", object=post)# <!--- The same works when passing an array of model objects. ---> <cfset posts = model("post").findAll(returnAs="objects")> #includePartial(posts)# #includePartial(partial="/shared/post", objects=posts)# </cfoutput>

invokeWithTransaction(method [, transaction, isolation ]) <!--- This is the method to be run inside a transaction --->
<cffunction name="transferFunds" returntype="boolean" output="false">
    <cfargument name="personFrom">
    <cfargument name="personTo">
    <cfargument name="amount">
    <cfif arguments.personFrom.withdraw(arguments.amount) and arguments.personTo.deposit(arguments.amount)>
        <cfreturn true>
    <cfelse>
        <cfreturn false>
    </cfif>
</cffunction>

<cfset david = model("Person").findOneByName("David")>
<cfset mary = model("Person").findOneByName("Mary")>
<cfset invokeWithTransaction(method="transferFunds", personFrom=david, personTo=mary, amount=100)>

requestIsAjax = isAjax();

isClass() <!--- Use the passed in `id` when we're already in an instance --->
<cffunction name="memberIsAdmin">
    <cfif isClass()>
        <cfreturn this.findByKey(arguments.id).admin>
    <cfelse>
        <cfreturn this.admin>
    </cfif>
</cffunction>

requestIsGet = isGet();

isInstance() <!--- Use the passed in `id` when we're not already in an instance --->
<cffunction name="memberIsAdmin">
    <cfif isInstance()>
        <cfreturn this.admin>
    <cfelse>
        <cfreturn this.findByKey(arguments.id).admin>
    </cfif>
</cffunction>

isNew() <!--- Create a new object and then check if it is new (yes, this example is ridiculous. It makes more sense in the context of callbacks for example) --->
<cfset employee = model("employee").new()>
<cfif employee.isNew()>
    <!--- Do something... --->
</cfif>

requestIsPost = isPost();

// Redirect non-secure connections to the secure version
if (!isSecure())
{
	redirectTo(protocol="https");
}

javaScriptIncludeTag([ sources, type, head, delim ]) <!--- view code --->
<head>
    <!--- Includes `javascripts/main.js` --->
    #javaScriptIncludeTag("main")#
    <!--- Includes `javascripts/blog.js` and `javascripts/accordion.js` --->
    #javaScriptIncludeTag("blog,accordion")#
    <!--- Includes external JavaScript file --->
    #javaScriptIncludeTag("https://ajax.googleapis.com/ajax/libs/jquery/1.4.4/jquery.min.js")#
</head>

<body>
    <!--- Will still appear in the `head` --->
    #javaScriptIncludeTag(source="tabs", head=true)#
</body>

key() <!--- Get an object and then get the primary key value(s) --->
<cfset employee = model("employee").findByKey(params.key)>
<cfset val = employee.key()>

#linkTo(text="Log Out", controller="account", action="logout")#
-> <a href="/account/logout">Log Out</a>

<!--- If you're already in the `account` controller, CFWheels will assume that's where you want the link to point --->
#linkTo(text="Log Out", action="logout")#
-> <a href="/account/logout">Log Out</a>

#linkTo(text="View Post", controller="blog", action="post", key=99)#
-> <a href="/blog/post/99">View Post</a>

#linkTo(text="View Settings", action="settings", params="show=all&sort=asc")#
-> <a href="/account/settings?show=all&amp;sort=asc">View Settings</a>

<!--- Given that a `userProfile` route has been configured in `config/routes.cfm` --->
#linkTo(text="Joe's Profile", route="userProfile", userName="joe")#
-> <a href="/user/joe">Joe's Profile</a>

<!--- Link to an external website --->
#linkTo(text="ColdFusion Framework", href="http://cfwheels.org/")#
-> <a href="http://cfwheels.org/">ColdFusion Framework</a>

<!--- Give the link `class` and `id` attributes --->
#linkTo(text="Delete Post", action="delete", key=99, class="delete", id="delete-99")#
-> <a class="delete" href="/blog/delete/99" id="delete-99">Delete Post</a>

#mailTo(emailAddress="[email protected]", name="Contact our Webmaster")#
-> <a href="mailto:[email protected]">Contact our Webmaster</a>

// Get the amount of the highest salary for all employees
highestSalary = model("employee").maximum("salary");

// Get the amount of the highest salary for employees in a given department
highestSalary = model("employee").maximum(property="salary", where="departmentId=##params.key##");

// Make sure a numeric value is always returned, even if no records are found to calculate the maximum for
highestSalary = model("employee").maximum(property="salary", where="salary > ##params.minSalary##", ifNull=0);

mimeTypes(extension [, fallback ]) <!--- Get the internally-stored MIME type for `xls` --->
<cfset mimeType = mimeTypes("xls")>

<!--- Get the internally-stored MIME type for a dynamic value. Fall back to a MIME type of `text/plain` if it's not found --->
<cfset mimeType = mimeTypes(extension=params.type, fallback="text/plain")>

// Get the amount of the lowest salary for all employees
lowestSalary = model("employee").minimum("salary");

// Get the amount of the lowest salary for employees in a given department
lowestSalary = model("employee").minimum(property="salary", where="departmentId=##params.key##");

// Make sure a numeric amount is always returned, even when there were no records analyzed by the query
lowestSalary = model("employee").minimum(property="salary", where="salary BETWEEN ##params.min## AND ##params.max##", ifNull=0);

<!--- This "Tag" version of the function accepts a `name` and `selected` instead of binding to a model object --->
<cfoutput>
    #minuteSelectTag(name="minuteOfMeeting", value=params.minuteOfMeeting)#
</cfoutput>

<!--- Only show 15-minute intervals --->
<cfoutput>
	#minuteSelectTag(name="minuteOfMeeting", value=params.minuteOfMeeting, minuteStep=15)#
</cfoutput>

model(name) <!--- The `model("author")` part of the code below gets a reference to the model from the application scope, and then the `findByKey` class level method is called on it --->
<cfset authorObject = model("author").findByKey(1)>

<!--- This "Tag" version of the function accepts a `name` and `selected` instead of binding to a model object --->
<cfoutput>
    #monthSelectTag(name="monthOfBirthday", selected=params.monthOfBirthday)#
</cfoutput>

<!--- In `models/User.cfc`, allow for `groupEntitlements` to be saved and deleted through the `user` object --->
<cffunction name="init">
	<cfset hasMany("groupEntitlements")>
	<cfset nestedProperties(association="groupEntitlements", allowDelete=true)>
</cffunction>

<!--- Create a new author in memory (not saved to the database) --->
<cfset newAuthor = model("author").new()>

<!--- Create a new author based on properties in a struct --->
<cfset newAuthor = model("author").new(params.authorStruct)>

<!--- Create a new author by passing in named arguments --->
<cfset newAuthor = model("author").new(firstName="John", lastName="Doe")>

<!--- If you have a `hasOne` or `hasMany` association setup from `customer` to `order`, you can do a scoped call. (The `newOrder` method below will call `model("order").new(customerId=aCustomer.id)` internally.) --->
<cfset aCustomer = model("customer").findByKey(params.customerId)>
<cfset anOrder = aCustomer.newOrder(shipping=params.shipping)>

obfuscateParam(param) <!--- Obfuscate the primary key value `99` --->
<cfset newValue = obfuscateParam(99)>

// This will only provide the `html` type and will ignore what was defined in the call to `provides()` in the `init()` function
onlyProvides("html");

allAuthors = model("author").findAll(page=1, perPage=25, order="lastName", handle="authorsData");
paginationData = pagination("authorsData");

#pagination().currentPage#
#pagination().totalPages#
#pagination().totalRecords#

<!--- Example 1: List authors page by page, 25 at a time --->
<!--- Controller code --->
<cfparam name="params.page" default="1">
<cfset allAuthors = model("author").findAll(page=params.page, perPage=25, order="lastName")>

<!--- View code --->
<ul>
    <cfoutput query="allAuthors">
        <li>##firstName## ##lastName##</li>
    </cfoutput>
</ul>
<cfoutput>##paginationLinks(action="listAuthors")##</cfoutput>

<!--- Example 2: Using the same model call above, show all authors with a window size of 5 --->
<!--- View code --->
<cfoutput>##paginationLinks(action="listAuthors", windowSize=5)##</cfoutput>

<!--- Example 3: If more than one paginated query is being run, then you need to reference the correct `handle` in the view --->
<!--- Controller code --->
<cfset allAuthors = model("author").findAll(handle="authQuery", page=5, order="id")>

<!--- View code --->
<ul>
    <cfoutput>##paginationLinks(action="listAuthors", handle="authQuery", prependToLink="<li>", appendToLink="</li>")##</cfoutput>
</ul>

<!--- Example 4: Call to `paginationLinks` using routes --->
<!--- Route setup in config/routes.cfm --->
<cfset addRoute(name="paginatedCommentListing", pattern="blog/[year]/[month]/[day]/[page]", controller="theBlog", action="stats")>
<cfset addRoute(name="commentListing", pattern="blog/[year]/[month]/[day]",  controller="theBlog", action="stats")>

<!--- Ccontroller code --->
<cfparam name="params.page" default="1">
<cfset comments = model("comment").findAll(page=params.page, order="createdAt")>

<!--- View code --->
<ul>
    <cfoutput>##paginationLinks(route="paginatedCommentListing", year=2009, month="feb", day=10)##</cfoutput>
</ul>

<!--- Provide a `label` and the required `objectName` and `property` --->
<cfoutput>
    #passwordField(label="Password", objectName="user", property="password")#
</cfoutput>

<!--- Display fields for passwords provided by the `passwords` association and nested properties --->
<fieldset>
	<legend>Passwords</legend>
	<cfloop from="1" to="##ArrayLen(user.passwords)##" index="i">
		#passwordField(label="Password ####i##", objectName="user", association="passwords", position=i, property="password")#
	</cfloop>
</fieldset>

<!--- Basic usage usually involves a `label`, `name`, and `value` --->
<cfoutput>
    #passwordFieldTag(label="Password", name="password", value=params.password)#
</cfoutput>

pluginNames() <!--- Check if the Scaffold plugin is installed --->
<cfif ListFindNoCase("scaffold", pluginNames())>
    <!--- do something cool --->
</cfif>

pluralize(word [, count, returnCount ]) <!--- Pluralize a word, will result in "people" --->
#pluralize("person")#

<!--- Pluralize based on the count passed in --->
Your search returned #pluralize(word="person", count=users.RecordCount)#

primaryKey([ position ]) <!--- Get the name of the primary key of the table mapped to the `employee` model (which is the `employees` table by default) --->
<cfset keyName = model("employee").primaryKey()>

primaryKeys([ position ]) <!--- Get a list of the names of the primary keys in the table mapped to the `employee` model (which is the `employees` table by default) --->
<cfset keyNames = model("employee").primaryKeys()>

properties() <!--- Get a structure of all the properties for an object --->
<cfset user = model("user").findByKey(1)>
<cfset props = user.properties()>

property(name [, column, sql, label, defaultValue ]) <!--- Tell Wheels that when we are referring to `firstName` in the CFML code, it should translate to the `STR_USERS_FNAME` column when interacting with the database instead of the default (which would be the `firstname` column) --->
<cfset property(name="firstName", column="STR_USERS_FNAME")>

<!--- Tell Wheels that when we are referring to `fullName` in the CFML code, it should concatenate the `STR_USERS_FNAME` and `STR_USERS_LNAME` columns --->
<cfset property(name="fullName", sql="STR_USERS_FNAME + ' ' + STR_USERS_LNAME")>

<!--- Tell Wheels that when displaying error messages or labels for form fields, we want to use `First name(s)` as the label for the `STR_USERS_FNAME` column --->
<cfset property(name="firstName", label="First name(s)")>

<!--- Tell Wheels that when creating new objects, we want them to be auto-populated with a `firstName` property of value `Dave` --->
<cfset property(name="firstName", defaultValue="Dave")>

propertyIsPresent(property) <!--- Get an object, set a value and then see if the property exists --->
<cfset employee = model("employee").new()>
<cfset employee.firstName = "dude">
<cfreturn employee.propertyIsPresent("firstName")><!--- Returns true --->

<cfset employee.firstName = "">
<cfreturn employee.propertyIsPresent("firstName")><!--- Returns false --->

propertyNames() <!--- Get a list of the property names in use in the user model --->
<cfset propNames = model("user").propertyNames()>

protectedProperties([ properties ]) <!--- In `models/User.cfc`, `firstName` and `lastName` cannot be changed through mass assignment operations like `updateAll()` --->
<cffunction name="init">
    <cfset protectedProperties("firstName,lastName")>
</cffunction>

provides("html,xml,json");

<!--- Basic example view code --->
<cfoutput>
	<fieldset>
		<legend>Gender</legend>
	    #radioButton(objectName="user", property="gender", tagValue="m", label="Male")#<br />
        #radioButton(objectName="user", property="gender", tagValue="f", label="Female")#
	</fieldset>
</cfoutput>

<!--- Shows radio buttons for selecting the genders for all committee members provided by the `members` association and nested properties --->
<cfoutput>
	<cfloop from="1" to="#ArrayLen(committee.members)#" index="i">
		<div>
			<h3>#committee.members[i].fullName#:</h3>
			<div>
				#radioButton(objectName="committee", association="members", position=i, property="gender", tagValue="m", label="Male")#<br />
				#radioButton(objectName="committee", association="members", position=i, property="gender", tagValue="f", label="Female")#
			</div>
		</div>
	</cfloop>
</cfoutput>

<!--- Basic usage usually involves a `label`, `name`, `value`, and `checked` value --->
<cfoutput>
	<fieldset>
		<legend>Gender</legend>
		#radioButtonTag(name="gender", value="m", label="Male", checked=true)#<br>
		#radioButtonTag(name="gender", value="f", label="Female")#
	</fieldset>
</cfoutput>

// Redirect to an action after successfully saving a user
if (user.save())
{
	redirectTo(action="saveSuccessful");
}

// Redirect to a specific page on a secure server
redirectTo(controller="checkout", action="start", params="type=express", protocol="https");

// Redirect to a route specified in `config/routes.cfm` and pass in the screen name that the route takes
redirectTo(route="profile", screenName="Joe");

// Redirect back to the page the user came from
redirectTo(back=true);

reload() <!--- Get an object, call a method on it that could potentially change values, and then reload the values from the database --->
<cfset employee = model("employee").findByKey(params.key)>
<cfset employee.someCallThatChangesValuesInTheDatabase()>
<cfset employee.reload()>

// Render a blank white page to the client
renderNothing();

// Render a view page for a different action within the same controller
renderPage(action="edit");

// Render a view page for a different action within a different controller
renderPage(controller="blog", action="new");

// Another way to render the blog/new template from within a different controller
renderPage(template="/blog/new");

// Render the view page for the current action but without a layout and cache it for 60 minutes
renderPage(layout=false, cache=60);

// Load a layout from a different folder within `views`
renderPage(layout="/layouts/blog");

// Don''t render the view immediately but rather return and store in a variable for further processing
myView = renderPage(returnAs="string");

// Render the partial `_comment.cfm` located in the current controller''s view folder
renderPartial("comment");

// Render the partial at `views/shared/_comment.cfm`
renderPartial("/shared/comment");

// Render just the text "Done!" to the client
renderText("Done!");

// Render serialized product data to the client
products = model("product").findAll();
renderText(SerializeJson(products));

// This will provide the formats defined in the `init()` function
products = model("product").findAll();
renderWith(products);

<!--- alternating row colors and shrinking emphasis --->
<cfoutput query="employees" group="departmentId">
	<div class="#cycle(values="even,odd", name="row")#">
		<ul>
			<cfoutput>
				<cfset rank = cycle(values="president,vice-president,director,manager,specialist,intern", name="position")>
				<li class="#rank#">#categories.categoryName#</li>
				<cfset resetCycle("emphasis")>
			</cfoutput>
		</ul>
	</div>
</cfoutput>

wheelsResponse = response();

<!--- Save the user object to the database (will automatically do an `INSERT` or `UPDATE` statement depending on if the record is new or already exists --->
<cfset user.save()>

<!--- Save the user object directly in an if statement without using `cfqueryparam` and take appropriate action based on the result --->
<cfif user.save(parameterize=false)>
	<cfset flashInsert(notice="The user was saved!")>
	<cfset redirectTo(action="edit")>
<cfelse>
	<cfset flashInsert(alert="Error, please correct!")>
	<cfset renderPage(action="edit")>
</cfif>