title: create rest-full login API in that i want to generate jwt token valid for certain time only
body: <p>Libraries code I get from <a href="https://github.com/b3457m0d3/JWT-CodeIgniter" rel="nofollow noreferrer">https://github.com/b3457m0d3/JWT-CodeIgniter</a>
  and I have to create login API in that i want to generate  token valid for certain time only.
  **comtroller </p>
  
  <pre><code>&lt;?php
  require APPPATH.'libraries/REST_Controller.php';
  class Comx extends REST_Controller 
  { 
      public function __construct()
      {
           parent::__construct();
              $this-&gt;load-&gt;library('session');
           $this-&gt;load-&gt;helper('cookie');
  
      $this-&gt;load-&gt;library('jwt');
  
      }
       public  function  generate_token($user_id)
      {
        //$this-&gt;load-&gt;library("jwt");
     $CONSUMER_KEY = '124578';
          $CONSUMER_SECRET = '456123';
          $CONSUMER_TTL = 60;
          var_dump( $this-&gt;jwt-&gt;encode(array(
            'consumerKey'=&gt;$CONSUMER_KEY,
        'userId'=&gt;$user_id,
            'issuedAt'=&gt;date(DATE_ISO8601, strtotime("now")),
            'ttl'=&gt;$CONSUMER_TTL
          ), $CONSUMER_SECRET));
      }
  
    **
  </code></pre>
  
  <blockquote>
    <p>// application/ libraries/jwt.php but this code give me error on line 89 of controller Undefined property: Comx::$JWT ?is it can not load library</p>
  </blockquote>
  
  <pre><code>&lt;?php
  defined('BASEPATH') OR exit('No direct script access allowed');
  /**
   * JSON Web Token implementation
   *
   * Minimum implementation used by Realtime auth, based on this spec:
   * http://self-issued.info/docs/draft-jones-json-web-token-01.html.
   *
   * @author Neuman Vong &lt;neuman@twilio.com&gt;
   * @minor changes for codeigniter &lt;b3457m0d3@interr0bang.net&gt;
   */
  class JWT
  {
      /**
       * @param string      $jwt    The JWT
       * @param string|null $key    The secret key
       * @param bool        $verify Don't skip verification process 
       *
       * @return object The JWT's payload as a PHP object
       */
      public function decode($jwt, $key = null, $verify = true)
      {
          $tks = explode('.', $jwt);
          if (count($tks) != 3) {
              throw new UnexpectedValueException('Wrong number of segments');
          }
          list($headb64, $payloadb64, $cryptob64) = $tks;
          if (null === ($header = $this-&gt;jsonDecode($this-&gt;urlsafeB64Decode($headb64)))
          ) {
              throw new UnexpectedValueException('Invalid segment encoding');
          }
          if (null === $payload = $this-&gt;jsonDecode($this-&gt;urlsafeB64Decode($payloadb64))
          ) {
              throw new UnexpectedValueException('Invalid segment encoding');
          }
          $sig = $this-&gt;urlsafeB64Decode($cryptob64);
          if ($verify) {
              if (empty($header-&gt;alg)) {
                  throw new DomainException('Empty algorithm');
              }
              if ($sig != $this-&gt;sign("$headb64.$payloadb64", $key, $header-&gt;alg)) {
                  throw new UnexpectedValueException('Signature verification failed');
              }
          }
          return $payload;
      }
      /**
       * @param object|array $payload PHP object or array
       * @param string       $key     The secret key
       * @param string       $algo    The signing algorithm
       *
       * @return string A JWT
       */
      public function encode($payload, $key, $algo = 'HS256')
      {
          $header = array('typ' =&gt; 'jwt', 'alg' =&gt; $algo);
          $segments = array();
          $segments[] = $this-&gt;urlsafeB64Encode($this-&gt;jsonEncode($header));
          $segments[] = $this-&gt;urlsafeB64Encode($this-&gt;jsonEncode($payload));
          $signing_input = implode('.', $segments);
          $signature = $this-&gt;sign($signing_input, $key, $algo);
          $segments[] = $this-&gt;urlsafeB64Encode($signature);
          return implode('.', $segments);
      }
      /**
       * @param string $msg    The message to sign
       * @param string $key    The secret key
       * @param string $method The signing algorithm
       *
       * @return string An encrypted message
       */
      public function sign($msg, $key, $method = 'HS256')
      {
          $methods = array(
              'HS256' =&gt; 'sha256',
              'HS384' =&gt; 'sha384',
              'HS512' =&gt; 'sha512',
          );
          if (empty($methods[$method])) {
              throw new DomainException('Algorithm not supported');
          }
          return hash_hmac($methods[$method], $msg, $key, true);
      }
      /**
       * @param string $input JSON string
       *
       * @return object Object representation of JSON string
       */
      public function jsonDecode($input)
      {
          $obj = json_decode($input);
          if (function_exists('json_last_error') &amp;&amp; $errno = json_last_error()) {
              $this-&gt;handleJsonError($errno);
          }
          else if ($obj === null &amp;&amp; $input !== 'null') {
              throw new DomainException('Null result with non-null input');
          }
          return $obj;
      }
      /**
       * @param object|array $input A PHP object or array
       *
       * @return string JSON representation of the PHP object or array
       */
      public function jsonEncode($input)
      {
          $json = json_encode($input);
          if (function_exists('json_last_error') &amp;&amp; $errno = json_last_error()) {
              $this-&gt;handleJsonError($errno);
          }
          else if ($json === 'null' &amp;&amp; $input !== null) {
              throw new DomainException('Null result with non-null input');
          }
          return $json;
      }
      /**
       * @param string $input A base64 encoded string
       *
       * @return string A decoded string
       */
      public function urlsafeB64Decode($input)
      {
          $remainder = strlen($input) % 4;
          if ($remainder) {
              $padlen = 4 - $remainder;
              $input .= str_repeat('=', $padlen);
          }
          return base64_decode(strtr($input, '-_', '+/'));
      }
      /**
       * @param string $input Anything really
       *
       * @return string The base64 encode of what you passed in
       */
      public function urlsafeB64Encode($input)
      {
          return str_replace('=', '', strtr(base64_encode($input), '+/', '-_'));
      }
      /**
       * @param int $errno An error number from json_last_error()
       *
       * @return void
       */
      private function handleJsonError($errno)
      {
          $messages = array(
              JSON_ERROR_DEPTH =&gt; 'Maximum stack depth exceeded',
              JSON_ERROR_CTRL_CHAR =&gt; 'Unexpected control character found',
              JSON_ERROR_SYNTAX =&gt; 'Syntax error, malformed JSON'
          );
          throw new DomainException(isset($messages[$errno])
              ? $messages[$errno]
              : 'Unknown JSON error: ' . $errno
          );
      }
  }
  </code></pre>