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

addColumn(table='members', columnType='string', columnName='status', limit=50);

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

addIndex(table='members', columnNames='username', unique=true);

addRecord(table='people',
		id = 1,
		title = "Mr",
		firstname = "Bruce",
		lastname = "Wayne", 
		email = "[email protected]",
		tel = "555-67869099", 
);

// 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:[email protected]">[email protected]</a> --->
#autoLink("Email us at [email protected]")#

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

changeColumn(table='members', columnType='string', columnName='status', limit=50);

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

t = changeTable(name='employees');
t.string(columnNames="fullName", default="", null=true, limit="255");
t.change();

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

<cfscript>

mapper()
    // Create a route like `photos/search`
    .resources(name="photos", nested=true)
        .collection()
            .get("search")
        .end()
    .end()
.end();

</cfscript>

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

// Example: create a users table
t = createTable(name='users'); 
	t.string(columnNames='firstname,lastname', default='', null=false, limit=50);
	t.string(columnNames='email', default='', null=false, limit=255); 
	t.string(columnNames='passwordHash', default='', null=true, limit=500);
	t.string(columnNames='passwordResetToken,verificationToken', default='', null=true, limit=500);
	t.boolean(columnNames='passwordChangeRequired,verified', default=false); 
	t.datetime(columnNames='passwordResetTokenAt,passwordResetAt,loggedinAt', default='', null=true); 
	t.integer(columnNames='roleid', default=0, null=false, limit=3);
	t.timestamps();
t.create();

// Example: Create a table with a different Primary Key
t = createTable(name='tokens', id=false);
	t.primaryKey(name='id', null=false, type="string", limit=35 );
	t.datetime(columnNames="expiresAt", null=false);
	t.integer(columnNames='requests', default=0, null=false);
	t.timestamps();
t.create();

// Example: Create a Join Table with composite primary keys
t = createTable(name='userkintins', id=false); 
	t.primaryKey(name="userid", null=false, limit=11);
	t.primaryKey(name='profileid', type="string", limit=11 );  
t.create();

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

function down() {
	transaction {
		try {
			// your code goes here
			dropTable('myTable');
		} catch (any e) {
			local.exception = e;
		}

		if (StructKeyExists(local, "exception")) {
			transaction action="rollback";
			throw(errorCode="1", detail=local.exception.detail, message=local.exception.message, type="any");
		} else {
			transaction action="commit";
		}
	}
}

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

// Using index hints
indexes = {
	author="idx_authors_123",
	post="idx_posts_123"
}
posts = model("author").findAll(where="firstname LIKE '#params.q#%' OR subject LIKE '#params.q#%'", include="posts", useIndex=indexes);

// 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='[email protected]' AND password='mypass'")`
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)
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();