controller

The think.controller.base class inherit from think.http.base class, controllers in project need to inherit it.

Inheritence with ES6:

export default class extends think.controller.base {
  indexAction(){

  }
}

Inheritence With Normal Way

module.exports = think.controller({
  indexAction(){

  }
})

Property

controller.http

Passed http object.

Methods

controller.ip()

  • return {String}

Get user ip of current request, it is equal to http.ip.

export default class extends think.controller.base {
  indexAction(){
    let ip = this.ip();
  }
}

controller.method()

  • return {String}

Get type of current request, and convert to lowercase.

export default class extends think.controller.base {
  indexAction(){
    let method = this.method(); //get or post ...
  }
}

controller.isMethod(method)

  • method {String} method
  • return {Boolean}

Judge type of current request is named types.

controller.isGet()

  • return {Boolean}

Judge is GET request or not.

controller.isPost()

  • return {Boolean}

Judge is POST request.

controller.isAjax(method)

  • method {String}
  • return {Boolean}

Judge is Ajax request, if named method, then as same as the type of request.

export default class extends think.controller.base {
  indexAction(){
    // is ajax and request type is POST
    let isAjax = this.isAjax('post');
  }
}

controller.isWebSocket()

  • return {Boolean}

Whether is websocket request or not.

controller.isCli()

  • return {Boolean}

Whether is run in command mode or not.

controller.isJsonp(callback)

  • callback {String} callback name
  • return {Boolean}

Whether is jsonp request.

controller.get(name)

  • name {String} parameter name

Get parameter of GET.

export default class extends think.controller.base {
  indexAction(){
    // get a parameter
    let value = this.get('xxx');
    // get all parameter
    let values = this.get();
  }
}

controller.post(name)

  • name {String} parameter name

Get parameter of POST data.

export default class extends think.controller.base {
  indexAction(){
    // get a value of parameter
    let value = this.post('xxx');
    // get all parameter of POST
    let values = this.post();
  }
}

controller.param(name)

  • name {String} parameter name

Get parameter value, first to read from POST, if return null, then get from GET.

controller.file(name)

  • name {String} field name of upload file

Get uploaded file, return value is a object, contains these method below:

{
  fieldName: 'file', // field name
  originalFilename: filename, // original file name
  path: filepath, // path of temp store file, need to move this path when using, or exists until request ends.
  size: 1000 // file size
}

If file not exist, this returning is an empty object {}.

controller.header(name, value)

  • name {String} header name
  • value {String} header value

Get or set header。

export default class extends think.controller.base {
  indexAction(){
    let accept = this.header('accept'); // get header
    this.header('X-NAME', 'thinks'); // set header
  }
}

controller.expires(time)

  • time {Number} expires time, the unit is seconds

Strong cache, set Cache-Control and Expires header information.

export default class extends think.controller.base {
  indexAction(){
    this.expires(86400); // set expire time to one day.
  }
}

controller.userAgent()

Get userAgent。

controller.referrer(onlyHost)

  • referrer {Boolean} whether only need host

Get referrer。

controller.cookie(name, value, options)

  • name {String} cookie name
  • value {String} cookie value
  • options {Object}

Get or set cookie。

export default class extends think.controller.base {
  indexAction(){
    // get value of cookie
    let value = this.cookie('think_name');
  }
}
export default class extends think.controller.base {
  indexAction(){
    // get value of cookie
    this.cookie('think_name', value, {
      timeout: 3600 * 24 * 7 // expires time is one week
    });
  }
}

controller.session(name, value)

  • name {String} session name
  • value {Mixed} session value
  • return {Promise}

Read, set and clean session。

Read Session
export default class extends think.controller.base {
  async indexAction(){
    // read session
    let value = await this.session('userInfo');
  }
}
set Session
export default class extends think.controller.base {
  async indexAction(){
    //set session
    await this.session('userInfo', data);
  }
}
Clean Session
export default class extends think.controller.base {
  async indexAction(){
    //清除当前用户的 session
    await this.session();
  }
}

controller.lang(lang, asViewPath)

  • lang {String} the setup of language
  • asViewPath {Boolean} whether add a directory layer for language template.

Read or set language.

controller.locale(key)

  • key {String}

Based on language to get the language version.

controller.redirect(url, statusCode)

  • url {String} the url to jump
  • statusCode {Number} status code, default is 302

Page jump.

controller.assign(name, value)

  • name {String | Object} variable name
  • value {Mixed} variable value

Assign variable into template.

export default class extends think.controller.base {
  indexAction(){
    // single assign
    this.assign('title', 'thinkjs');
    // multi-assign
    this.assign({
      name: 'xxx',
      desc: 'yyy'
    })
  }
}

controller.fetch(templateFile)

  • templateFile {String} tempate file path
  • return {Promise}

Get the parsed template content.

Get directly
// suppose the file path is /foo/bar/app/home/controller/index.js
export default class extends think.controller.base {
  async indexAction(){
    // home/index_index.html
    let content = await this.fetch();
  }
}
Change action
// suppose file path is /foo/bar/app/home/controller/index.js
export default class extends think.controller.base {
  async indexAction(){
    // home/index_detail.html
    let content = await this.fetch('detail');
  }
}
Change controller and action
// suppose file path is /foo/bar/app/home/controller/index.js
export default class extends think.controller.base {
  async indexAction(){
    // home/user_detail.html
    let content = await this.fetch('user/detail');
  }
}
Change module, controller 和 action
// suppose file path is /foo/bar/app/home/controller/index.js
export default class extends think.controller.base {
  async indexAction(){
    // admin/user_detail.html
    let content = await this.fetch('admin/user/detail');
  }
}
Change file extension
// suppose file path is /foo/bar/app/home/controller/index.js
export default class extends think.controller.base {
  async indexAction(){
    // home/index_detail.xml
    let content = await this.fetch('detail.xml');
  }
}
Get absolute file path
// suppose file path is /foo/bar/app/home/controller/index.js
export default class extends think.controller.base {
  async indexAction(){
    // /home/xxx/aaa/bbb/c.html
    let content = await this.fetch('/home/xxx/aaa/bbb/c.html');
  }
}

controller.display(templateFile)

  • templateFile {String} template file path

Output template content to browser side. strategy of finding template is the same as controller.fetch.

controller.jsonp(data)

  • data {Mixed} content to output

Using the way of jsonp to output content, after getting callback's name and security filter then output.

export default class extends think.controller.base {
  indexAction(){
    this.jsonp({name: 'thinkjs'});
    //writes
    'callback_fn_name({name: "thinkjs"})'
  }
}

controller.json(data)

  • data {Mixed} the output content

Json way to output.

controller.status(status)

  • status {Number} status code, default is 404

Set status code.

controller.deny(status)

  • status {String} status code, default is 403

Deny current request.

controller.write(data, encoding)

  • data {mixed} the output content
  • encoding {String} charset

Output content.

controller.end(data, encoding)

  • data {mixed} the output content
  • encoding {String} charset

After output content, end current request.

controller.type(type, charset)

  • type {String} Content-Type
  • charset {Boolean} wheher append charset or not

Set Content-Type。

controller.download(filePath, contentType, fileName)

  • filePath {String} specified path of download file
  • content-Type {String} Content-Type
  • fileName {String} error file name

Download file.

export default class extends think.controller.base {
  indexAction(){
    let filePath = think.RESOUCE_PATH + '/a.txt';
    // auto identify Content-Type, save file to a.txt
    this.download(filePath);
  }
}
export default class extends think.controller.base {
  indexAction(){
    let filePath = think.RESOUCE_PATH + '/a.log';
    // auto identify Content-Type, save file to b.txt
    this.download(filePath, 'b.txt');
  }
}
export default class extends think.controller.base {
  indexAction(){
    let filePath = think.RESOUCE_PATH + '/a.log';
    // specify Content-Type to text/html, save file to b.txt
    this.download(filePath, 'text/html', 'b.txt');
  }
}

controller.success(data, message)

  • data {Mixed} the output data
  • message {String} appended message

Output an normal formatted data, often after operate success.

http.success({name: 'thinkjs'});
//writes
{
  errno: 0,
  errmsg: '',
  data: {
    name: 'thinkjs'
  }
}

Client can based on error is 0 or not to judge current request is success.

controller.fail(errno, errmsg, data)

  • errno {Number} error number
  • errmsg {String} error message
  • data {Mixed} extra data

Output an unusual formatted data, normally after operate failed.

Notice: field name errno and errmsg can been modified in config.

http.fail(100, 'fail')
//writes
{
  errno: 100,
  errmsg: 'fail',
  data: ''
}

In this way, client will get detail error number and error message, then show message according to the need.

Notice: filed name errno and errmsg can been modified in config.

controller.sendTime(name)

  • name {String} header key

The execute time of send request, send with header.