// Make `isActive` the only property that can be set through mass assignment operations like `updateAll()`.
config() {
	accessibleProperties("isActive");
}

// Add an error to the `email` property.
this.addError(property="email", message="Sorry, you are not allowed to use that email. Try again, please.");

// Add an error on the object that's not specific to a single property.
this.addErrorToBase(message="Your email address must be the same as your domain name.");

// Add the `js` format
addFormat(extension="js", mimeType="text/javascript");

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

// Instruct CFWheels to call the `fixObj` method after an object has been created.
afterCreate("fixObj");

// Instruct CFWheels to call the `fixObj` method after an object has been deleted.
afterDelete("fixObj");

// Instruct CFWheels to call the `setTime` method after getting objects or records with one of the finder methods.
config() {
	afterFind("setTime");
}

function setTime(){
	arguments.fetchedAt = Now();
	return arguments;
}

// Instruct CFWheels to call the `fixObj` method after an object has been initialized (i.e. after creating it or fetching it with a finder method).
afterInitialization("fixObj");

// Instruct CFWheels to call the `fixObj` method after a new object has been created.
afterNew("fixObj");

// Instruct CFWheels to call the `fixObj` method after an object has been saved.
afterSave("fixObj");

// Instruct CFWheels to call the `fixObj` method after an object has been updated.
afterUpdate("fixObj");

// Instruct CFWheels to call the `fixObj` method after an object has been validated.
afterValidation("fixObj");

// Instruct CFWheels to call the `fixObj` method after a new object has been validated.
afterValidationOnCreate("fixObj");

// Instruct CFWheels to call the `fixObj` method after an existing object has been validated.
afterValidationOnUpdate("fixObj");

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

// Get all the errors for the `user` object.
errorInfo = user.allErrors();

// Sample return of method.
[
	{
  	message: 'Username must not be blank.',
    name: 'usernameError',
    property: 'username'
  },
  {
  	message: 'Password must not be blank.',
    name: 'passwordError',
    property: 'password'
  }
]

<!--- Needed here because we're not using `startFormTag`. --->
<form action="#urlFor(route='posts')#" method="post">
  #authenticityTokenField()#
</form>
  
<!--- Not needed here because we're not POSTing the form. --->
<form action="#urlFor(route='invoices')#" method="get">
</form>

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

<!--- Will output: Email us at <a href="mailto:info@cfwheels.org">info@cfwheels.org</a> --->
#autoLink("Email us at info@cfwheels.org")#

// Disable automatic validations (for example when automatic validations are enabled globally, but we want to disable just for this model).
config() {
	automaticValidations(false);
}

// 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
beforeCreate("fixObj");

// Instruct CFWheels to call the `fixObj` method
beforeDelete("fixObj");

// Instruct CFWheels to call the `fixObj` method
beforeSave("fixObj");

// Instruct CFWheels to call the `fixObj` method
beforeUpdate("fixObj");

// Instruct CFWheels to call the `fixObj` method
beforeValidation("fixObj");

// Instruct CFWheels to call the `fixObj` method
beforeValidationOnCreate("fixObj");

// Instruct CFWheels to call the `fixObj` method
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 --->
#startFormTag(action="something")#
    <!--- Form Controls go here --->
    #buttonTag(content="Submit this form", value="save")#
#endFormTag()#

#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 a sentence, will result in "Wheels is a framework"--->
#capitalize("wheels is a framework")#

// Get a member object and change the `email` property on it
member = model("member").findByKey(params.memberId);
member.email = params.newEmail;

// Get the previous value (what the `email` property was before it was changed)
oldValue = member.changedFrom("email");

// The above can also be done using a dynamic function like this
oldValue = member.emailChangedFrom();

// 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)
member = model("member").findByKey(params.memberId);
member.firstName = params.newFirstName;
member.email = params.newEmail;
changedProperties = member.changedProperties();

<!--- Basic example of a check box for a boolean field --->
#checkBox(objectName="photo", property="isPublic", label="Display this photo publicly.")#

<!--- Shows check boxes for selecting public access for all photos provided by the `photos` association and nested properties --->
<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>

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

<!--- Example 2: Loop over a query to display choices and whether or not they are checked --->
// Controller code
pizza = model("pizza").findByKey(session.pizzaId);
selectedToppings = pizza.toppings();
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();

// Clear all errors on the object as a whole
this.clearErrors();

// Clear all errors on `firstName`
this.clearErrors("firstName");

<!--- 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` --->
#contentForLayout()#

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
newAuthor = model("author").create(params.author);

// Same as above using named arguments
newAuthor = model("author").create(firstName="John", lastName="Doe");

// Same as above using both named arguments and a struct
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.)
aCustomer = model("customer").findByKey(params.customerId);
anOrder = aCustomer.createOrder(shipping=params.shipping);

// Create an empty migration file
result=application.wheels.migrator.createMigration("MyMigrationFile");

// Or Create a migration file from the create-table template
result=application.wheels.migrator.createMigration("MyMigrationFile","create-table");

<head>
  #csrfMetaTags()#
</head>

<!--- 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>
				rank = cycle(values="president,vice-president,director,manager,specialist,intern", name="position")>
				<li class="#rank#">#categories.categoryName#</li>
				resetCycle("emphasis")>
			</cfoutput>
		</ul>
	</div>
</cfoutput>

// In models/User.cfc.
config() {
	// Tell Wheels to use the data source named `users_source` instead of the default one whenever this model makes SQL calls.
	dataSource("users_source");
}

<!--- View code --->
#dateSelect(objectName="user", property="dateOfBirth")#

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

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

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

<!--- View code --->
#dateTimeSelect(objectName="article", property="publishedAt")#

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

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

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

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

<cfscript>

mapper()
    // Route name:  articleReview
    // Example URL: /articles/987/reviews/12542
    // Controller:  Reviews
    // Action:      delete
    .delete(name="articleReview", pattern="articles/[articleKey]/reviews/[key]", to="reviews##delete")

    // Route name:  cookedBooks
    // Example URL: /cooked-books
    // Controller:  CookedBooks
    // Action:      delete
    .delete(name="cookedBooks", controller="cookedBooks", action="delete")

    // Route name:  logout
    // Example URL: /logout
    // Controller:  Sessions
    // Action:      delete
    .delete(name="logout", to="sessions##delete")

    // Route name:  clientsStatus
    // Example URL: /statuses/4918
    // Controller:  clients.Statuses
    // Action:      delete
    .delete(name="statuses", to="statuses##delete", package="clients")

    // Route name:  blogComment
    // Example URL: /comments/5432
    // Controller:  blog.Comments
    // Action:      delete
    .delete(
        name="comment",
        pattern="comments/[key]",
        to="comments##delete",
        package="blog"
    )
.end();

</cfscript>

// Get a post object and then delete it from the database.
post = model("post").findByKey(33);
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.)
post = model("post").findByKey(params.postId);
comment = model("comment").findByKey(params.commentId);
post.deleteComment(comment);

// Delete all inactive users without instantiating them (will skip validation and callbacks).
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.)
post = model("post").findByKey(params.postId);
howManyDeleted = post.deleteAllComments();

// Delete the user with the primary key value of `1`.
result = model("user").deleteByKey(1);

// Delete the user that signed up last.
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).
aUser = model("user").findByKey(params.userId);
aUser.deleteProfile();

// Get the original value from an obfuscated one
originalValue = deobfuscateParam("b7ab9a50");

// Controller code.
rightNow = Now();
aWhileAgo = DateAdd("d", -30, rightNow);

// View code.
<!--- Will output: about 1 month --->
#distanceOfTimeInWords(aWhileAgo, rightNow)#

<cfscript>

mapper()
    .namespace("admin")
        .resources("products")
    .end() // Ends the `namespace` block.

    .scope(package="public")
        .resources(name="products", nested=true)
          .resources("variations")
        .end() // Ends the nested `resources` block.
    .end() // Ends the `scope` block.
.end(); // Ends the `mapper` block.

</cfscript>

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

// Check how many errors are set on the object
if(author.errorCount() GTE 10){
    // Do something to deal with this very erroneous author here...
}

// Check how many errors are associated with the `email` property
if(author.errorCount("email") gt 0){
    // Do something to deal with this erroneous author here...
}

// Get all errors related to the email address of the user object
errors = user.errorsOn("emailAddress");

// Get all general type errors for the user object
errors = user.errorsOnBase();

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

// 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` --->
#fileField(label="Photo", objectName="photo", property="imageFile")#


<!--- 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` --->
#fileFieldTag(label="Photo", name="photo", value=params.photo)#

// 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
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)
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)  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)  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#")
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#'" )
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)
post = model("post").findByKey(params.postId);
comments = post.comments();

// If you have an `Order` model with properties for `productId`, `amount` and a calculated property named `totalAmount` (set up as `property(name="totalAmount", sql="SUM(amount)")`), then you can do the following to get the ids for all products with over $1,000 in sales (the SQL will be created using `HAVING` instead of `WHERE` in this case since you're getting an aggregate value for a calculated property)
ids = model("order").findAll(group="productId", where="totalAmount > 1000");

// 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
auth = model("author").findByKey(99);

// Getting an author based on a form/URL value and then checking if it was found
auth = model("author").findByKey(params.key);
if(!isObject(auth)){
    flashInsert(message="Author #params.key# was not found");
    redirectTo(back=true);
}

// 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)
comment = model("comment").findByKey(params.commentId);
post = comment.post();

// Getting the most recent order as an object from the database
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'")`
person = model("user").findOneByLastName("Smith");

// Getting a specific user using a dynamic finder. Same as calling `model("user").findOne(where"email='someone@somewhere.com' AND password='mypass'")`
user = model("user").findOneByEmailAndPassword("someone@somewhere.com,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)
user = model("user").findByKey(params.userId);
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)
post = model("post").findByKey(params.postId);
comment = post.findOneComment(where="text='I Love Wheels!'");

// 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 --->
#flashMessages()#

<!--- 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 --->
#flashMessages(key="success")#

<!--- 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 --->
#flashMessages(keys="success,alert")#

<!--- 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>

<cfscript>

mapper()
    // Route name:  post
    // Example URL: /posts/my-post-title
    // Controller:  Posts
    // Action:      show
    .get(name="post", pattern="posts/[slug]", to="posts##show")

    // Route name:  posts
    // Example URL: /posts
    // Controller:  Posts
    // Action:      index
    .get(name="posts", controller="posts", action="index")

    // Route name:  authors
    // Example URL: /the-scribes
    // Controller:  Authors
    // Action:      index
    .get(name="authors", pattern="the-scribes", to="authors##index")

    // Route name:  commerceCart
    // Example URL: /cart
    // Controller:  commerce.Carts
    // Action:      show
    .get(name="cart", to="carts##show", package="commerce")

    // Route name:  extranetEditProfile
    // Example URL: /profile/edit
    // Controller:  extranet.Profiles
    // Action:      edit
    .get(
        name="editProfile",
        pattern="profile/edit",
        to="profiles##edit",
        package="extranet"
    )

    // Example scoping within a nested resource
    .resources(name="users", nested=true)
        // Route name:  activatedUsers
        // Example URL: /users/activated
        // Controller:  Users
        // Action:      activated
        .get(name="activated", to="users##activated", on="collection")

        // Route name:  preferencesUsers
        // Example URL: /users/391/preferences
        // Controller:  Preferences
        // Action:      index
        .get(name="preferences", to="preferences##index", on="member")
    .end()
.end();

</cfscript>

// Get the current value for the `tableNamePrefix` Wheels setting
setting = get("tableNamePrefix");

// Get the default for the `message` argument of the `validatesConfirmationOf` method
setting = get(functionName="validatesConfirmationOf", name="message");

// Get array of available migrations
migrations = application.wheels.migrator.getAvailableMigrations();

if(ArrayLen(migrations)){
	 latestVersion = migrations[ArrayLen(migrations)].version;
} else {
	 latestVersion = 0;
}

// Get current database version
currentVersion = application.wheels.migrator.getCurrentMigrationVersion();

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

// Get a member object and change the `email` property on it
member = model("member").findByKey(params.memberId);
member.email = params.newEmail;

// Check if the `email` property has changed
if(member.hasChanged("email")){
    // Do something...
}

// The above can also be done using a dynamic function like this
if(member.emailHasChanged()){
    // Do something...
}

// Check if the post object has any errors set on it 
if(post.hasErrors()){
    // Send user to a form to correct the errors... 
}

// 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 `config()` method.
hasMany(name="subscriptions", shortcut="magazines", through="publication,subscriptions");

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

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

<!--- 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>

<!--- 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");

// Get an object, set a value and then see if the property exists
employee = model("employee").new();
employee.firstName = "dude";
employee.hasProperty("firstName"); // returns true

// This is also a dynamic method that you could do
employee.hasFirstName();

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

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

<!--- Will output: You searched for: <span class="highlight">CFWheels --->
#highlight(text="You searched for: CFWheels", phrases="CFWheels")#

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

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

<!--- 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")#

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

<!--- 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--->
contentFor(head='<meta name="robots" content="noindex,nofollow">');
contentFor(head='<meta name="author" content="wheelsdude@wheelsify.com">');

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

// 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
if(!includedInObject(objectName="customer", association="subscriptions", keys="#customer.key()#,#swimsuitEdition.id#")){
    assignSalesman(customer);
}

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

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

// 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>

// This is the method to be run inside a transaction.
public boolean function transferFunds(required any personFrom, required any personTo, required numeric amount) {
	if (arguments.personFrom.withdraw(arguments.amount) && arguments.personTo.deposit(arguments.amount)) {
		return true;
	} else {
		return false;
	}
}

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

requestIsAjax = isAjax();

// Use the passed in `id` when we're already in an instance
function memberIsAdmin(){
	if(isClass()){
		return this.findByKey(arguments.id).admin;
	} else {
		return this.admin;
	}
}

requestIsGet = isGet();

// Use the passed in `id` when we're not already in an instance
function memberIsAdmin(){
	if(isInstance()){
		return this.admin;
	} else {
		return this.findByKey(arguments.id).admin;
	}
}

// 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)
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");
}

<!--- 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>

// Get an object and then get the primary key value(s)
employee = model("employee").findByKey(params.key);
val = employee.key();

#linkTo(text="Log Out", controller="account", action="logout")#
<!--- Ouputs: <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")#
<!--- Ouputs: <a href="/account/logout">Log Out</a> --->

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

#linkTo(text="View Settings", action="settings", params="show=all&amp;sort=asc")#
<!--- Ouputs: <a href="/account/settings?show=all&amp;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")#
<!--- Ouputs: <a href="/user/joe">Joe's Profile</a> --->

<!--- Link to an external website --->
#linkTo(text="ColdFusion Framework", href="http://cfwheels.org/")#
<!--- Ouputs: <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")#
<!--- Ouputs: <a class="delete" href="/blog/delete/99" id="delete-99">Delete Post</a> --->

#mailTo(emailAddress="webmaster@yourdomain.com", name="Contact our Webmaster")#
<!--- Outputs: <a href="mailto:webmaster@yourdomain.com">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);

// Migrate to a specific version
// Returns a message with the result
result=application.wheels.migrator.migrateTo(version);

// Get the internally-stored MIME type for `xls`
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
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>

// 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
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>

<cfscript>

mapper()
    .namespace("api")
        .namespace("v2")
            // Route name:  apiV2Products
            // Example URL: /api/v2/products/1234
            // Controller:  api.v2.Products
            .resources("products")
        .end()

        .namespace("v1")
            // Route name:  apiV1Users
            // Example URL: /api/v1/users
            // Controller:  api.v1.Users
            .get(name="users", to="users##index")
        .end()
    .end()

    .namespace(name="foo", package="foos", path="foose")
        // Route name:  fooBars
        // Example URL: /foose/bars
        // Controller:  foos.Bars
        .post(name="bars", to="bars##create")
    .end()
.end();

</cfscript>

// In `models/User.cfc`, allow for `groupEntitlements` to be saved and deleted through the `user` object.
function config(){
	hasMany("groupEntitlements");
	nestedProperties(association="groupEntitlements", allowDelete=true);
}

// Create a new author in memory (not saved to the database)
newAuthor = model("author").new();

// Create a new author based on properties in a struct
newAuthor = model("author").new(params.authorStruct);

// Create a new author by passing in named arguments
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.)
aCustomer = model("customer").findByKey(params.customerId);
anOrder = aCustomer.newOrder(shipping=params.shipping);

// Obfuscate the primary key value `99`
newValue = obfuscateParam(99);

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

<cfscript>

mapper()
    .package("public")
        // Example URL: /products/1234
        // Controller:  public.Products
        .resources("products")
    .end()

    // Example URL: /users/4321
    // Controller:  Users
    .resources(name="users", nested=true)
        // Calling `package` here is useful to scope nested routes for the `users`
        // resource into a subfolder.
        .package("users")
            // Example URL: /users/4321/profile
            // Controller:  users.Profiles
            .resource("profile")
        .end()
    .end()
.end();

</cfscript>

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

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