/**
* The register method is responsible for checking/validating
* the given input (email and password) and either return an error code or
* create a new user.
*
* @return mixed
*/
public function register()
{
$validateUser = $this->validateUser();
if ($validateUser->status == 'error') {
return \Response::json($validateUser);
} else {
//All's good, create a new user
$user = User::create(['name' => \Request::get('name'), 'email' => \Request::get('email'), 'password' => bcrypt(\Request::get('password'))]);
if (!\Request::has('role')) {
$role['role'] = 'mobile';
} else {
$role['role'] = 'web';
}
//assign role to user
$role = Role::where('name', $role)->first();
$user->roles()->save($role);
$device = $this->sanitizeDevice($user->id);
$this->deviceService->store($user->id, $device);
//Retrieve the JWT and send back to the Controller
$token = \JWTAuth::fromUser($user);
$response = new ApiResponse();
$response->status = 'success';
$response->message = ['token' => $token];
}
return \Response::json($response);
}
/**
* Decode token request header
*
* @return object
*/
public static function getToken()
{
$jwt = \JWTAuth::getToken();
if (!$jwt) {
return null;
}
return \JWTAuth::decode($jwt)->get();
}
protected function login()
{
if (isset($this->token)) {
return;
}
$user = User::where('email', '=', env('TEST_MAIL'))->get()[0];
$this->token = JWTAuth::fromUser($user);
}
public function testRoute()
{
$customer = Customer::whereEmail('*****@*****.**')->first();
$token1 = JWTAuth::attempt(["email" => '*****@*****.**', "password" => "admin"]);
$token2 = JWTAuth::fromUser($customer);
$access_token = $token1;
$response = $this->call('GET', '/testtoken', [], [], array('HTTP_authorization' => 'bearer ' . $access_token, "HTTP_custom" => "custom header"));
$this->assertTrue($response->isOk());
}
/**
* @param \App\User $user
*/
protected function headers($user = null)
{
$headers = ['Accept' => 'application/json'];
if (!is_null($user)) {
$token = JWTAuth::fromUser($user);
JWTAuth::setToken($token);
$headers['HTTP_AUTHORIZATION'] = 'Bearer ' . (string) $token;
}
return $headers;
}
public function info()
{
try {
$token = \JWTAuth::getToken();
$payload = \JWTAuth::getPayload($token);
} catch (JWTException $e) {
return ['error' => 'no auth token provided'];
}
$user = User::where('id', $payload['user_id'])->first();
return $user;
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
if (!\JWTAuth::getToken()) {
return response()->json(['status' => 401, 'error' => 'token_absent'], 200);
} else {
try {
$authenticate = \JWTAuth::parseToken()->authenticate();
if (!$authenticate) {
return response()->json(['status' => 401, 'error' => 'user_not_found'], 200);
}
} catch (Tymon\JWTAuth\Exceptions\TokenExpiredException $e) {
return response()->json(['status' => 401, 'error' => 'token_expired'], 200);
} catch (Tymon\JWTAuth\Exceptions\TokenInvalidException $e) {
return response()->json(['status' => 401, 'error' => 'token_invalid'], 200);
}
}
return $next($request);
}
/**
*
* @param Request $request
*/
public function __construct(Request $request)
{
$this->request = $request;
$this->middleware('jwt.auth');
$this->middleware('api', ['except' => 'GenerateApiKey']);
$user = \JWTAuth::parseToken()->authenticate();
$this->user = $user;
$ticket = new TicketController();
$this->ticket = $ticket;
$model = new Tickets();
$this->model = $model;
$thread = new Ticket_Thread();
$this->thread = $thread;
$attach = new Ticket_attachments();
$this->attach = $attach;
$ticketRequest = new TicketRequest();
$this->ticketRequest = $ticketRequest;
$faveoUser = new User();
$this->faveoUser = $faveoUser;
$team = new Teams();
$this->team = $team;
$setting = new Settings();
$this->setting = $setting;
$helptopic = new Help_topic();
$this->helptopic = $helptopic;
$slaPlan = new Sla_plan();
$this->slaPlan = $slaPlan;
$priority = new Priority();
$this->priority = $priority;
$department = new Department();
$this->department = $department;
$source = new Ticket_source();
$this->source = $source;
}
/**
* Update a address by id
* @return array
*/
public function update(Request $request, $id)
{
$jugador_data = json_decode($request->getContent(), true);
\JWTAuth::parseToken();
$user = \JWTAuth::parseToken()->authenticate();
$editedJugador = NULL;
try {
if ($id == $user->id_jugador) {
$editedJugador = $this->repository->update($jugador_data, $id);
$file = $request->file("foto");
if (!empty($file)) {
$file->move("images/jugadores/", $user->id_jugador . ".jpg");
}
return response()->json($editedJugador);
} else {
return ResponseMessage::invalidPermission();
}
} catch (\Exception $e) {
if ($e instanceof ValidatorException) {
return response()->json($e->toArray(), 400);
} else {
return response()->json($e->getMessage(), 500);
}
}
}
public function join($eventId)
{
$user = \JWTAuth::parseToken()->toUser();
$event = \App\Event::find($eventId);
$event->users()->attach($user->id);
response()->json(['message' => 'User Joined Event'], 200);
}
public function login(Request $request)
{
$credentials = $request->only('email', 'password');
if (!($token = \JWTAuth::attempt($credentials))) {
return response()->json(['error' => 'invalid_credentials'], 401);
}
return response()->json(['token' => $token, 'user' => ['id' => \JWTAuth::toUser($token)->id, 'name' => \JWTAuth::toUser($token)->name, 'email' => \JWTAuth::toUser($token)->email]]);
}
/**
* Updates particular creator
*
* @param int $id
* @return boolean
*/
public function update()
{
$user = JWTAuth::parseToken()->toUser();
$creator = $this->creator->createCreator(Input::all(), $user['id']);
return $this->response->array($creator);
// $user = JWTAuth::parseToken()->toUser();
// $creator = $this->creator->updateCreator(Input::all(), $user['id']);
// return $this->response->array($creator);
}
/**
* @param \App\User $user
*/
protected function headers($user = null)
{
$headers = ['Accept' => 'application/json'];
if (!is_null($user)) {
$token = JWTAuth::fromUser($user);
JWTAuth::setToken($token);
$headers['Authorization'] = 'Bearer ' . $token;
}
return $headers;
}
public function call($method, $uri, $params = array(), $cookies = array(), $files = array(), $headers = array(), $content = null)
{
if (!$this->noTokenNextReq) {
$headers['HTTP_Authorization'] = 'Bearer ' . $this->token;
} else {
$this->noTokenNextReq = false;
JWTAuth::unsetToken();
}
parent::call($method, $uri, $params, $cookies, $files, $headers, $content);
}
public function authenticate($userCredentials)
{
if(!$token = \JWTAuth::attempt($credentials)) {
//throw exception
}
$user = \JWTAuth::setToken($token)->toUser();
return $user;
}
public function authenticate(Request $request)
{
try {
$credentials = \Request::only('email', 'password');
if (!($token = \JWTAuth::attempt($credentials))) {
return \Response::json(['error' => 'invalid_credentials'], 401);
}
return \Response::json(compact('token'));
} catch (JWTException $e) {
return \Response::json(['error' => 'could_not_create_token'], 500);
}
}
/**
* Handle login request to the application.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
*/
public function store(Request $request)
{
$validator = \Validator::make($request->all(), ['email' => 'required|email', 'password' => 'required|min:6']);
if ($validator->fails()) {
return $this->respondValidationError($validator);
}
$token = is_api_request() ? \JWTAuth::attempt($request->only('email', 'password')) : Auth::attempt($request->only('email', 'password'), $request->has('remember'));
if (!$token) {
return $this->respondLoginFailed();
}
event('users.login', [Auth::user()]);
return $this->respondCreated($request->input('return'), $token);
}
public function storeToken()
{
try {
if ($user = Sentinel::stateless(Input::only('email', 'password'))) {
return \JWTAuth::fromUser($user);
} else {
throw new UnauthorizedHttpException('Invalid Credentials');
}
} catch (\Exception $e) {
//dd(get_class($e));
throw new UnauthorizedHttpException('Unauthorized', $e->getMessage());
}
}
/**
* Authenticate the user by their credentials
*
* @param array $data
* @return \Illuminate\Http\JsonResponse
*/
public function authenticate(array $data)
{
try {
// Attempt to verify the credentials and create a token for the user
if (!($token = \JWTAuth::attempt($data))) {
return $this->response()->array(['error' => 'invalid_credentials'])->setStatusCode(401);
}
} catch (JWTException $e) {
// Something went wrong whilst attempting to encode the token
return $this->response()->array(['error' => 'could_not_create_token'])->setStatusCode(500);
}
// Authentication passed and return the token
return $token;
}
public function authenticate(Request $request)
{
$credentials = $request->only('email', 'password');
try {
// verify the credentials and create a token for the user
if (!($token = JWTAuth::attempt($credentials))) {
return response()->json(['error' => 'invalid_credentials'], 401);
}
} catch (JWTException $e) {
// something went wrong
return response()->json(['error' => 'could_not_create_token'], 500);
}
// if no errors are encountered we can return a JWT
return response()->json(compact('token'));
}
public function expired($e)
{
$token = \JWTAuth::parseToken();
Config::package('tymon/jwt-auth', 'jwt');
$ttl = Config::get('jwt::refresh_ttl');
$iat = Carbon::createFromTimestamp($token->getPayload()->get('iat'));
$now = Carbon::now();
// if renew ttl is expired too, return 401, otherwise let
// the application generate a new token to frontend
if ($iat->diffInMinutes($now) >= $ttl) {
unset($iat, $now, $ttl);
return response_failure(Lang::get('errors.api.auth.expired'), Config::get('status.error.unauthorized'));
}
unset($iat, $now, $ttl);
}
public function getAuthenticatedUser()
{
try {
if (!($user = JWTAuth::parseToken()->authenticate())) {
return response()->json(['user_not_found'], 404);
}
} catch (Tymon\JWTAuth\Exceptions\TokenExpiredException $e) {
return response()->json(['token_expired'], $e->getStatusCode());
} catch (Tymon\JWTAuth\Exceptions\TokenInvalidException $e) {
return response()->json(['token_invalid'], $e->getStatusCode());
} catch (Tymon\JWTAuth\Exceptions\JWTException $e) {
return response()->json(['token_absent'], $e->getStatusCode());
}
// the token is valid and we have found the user via the sub claim
return response()->json(compact('user'));
}
public function createUser(Request $request)
{
Log::debug("JWTAuthController.createUser.begin");
try {
$credentials = $request->json()->all();
$credentials['password'] = Hash::make($credentials['password']);
Log::debug("JWTAuthController.createUser:"******"JWTAuthController.createUser.exception:" . $e->getMessage());
return response()->json($e->getMessage());
}
Log::debug("JWTAuthController.createUser.end");
return response()->json('ok');
}
/**
* Update a address by id
* @return array
*/
public function update(Request $request, $id)
{
\JWTAuth::parseToken();
$user = \JWTAuth::parseToken()->authenticate();
$alert_data = json_decode($request->getContent(), true);
try {
$alert = $this->repository->update($alert_data, $id);
return response()->json($alert);
} catch (\Exception $e) {
if ($e instanceof ValidatorException) {
return response()->json($e->toArray(), 400);
} else {
return response()->json($e->getMessage(), 500);
}
}
}
public function signin()
{
$credentials = \Input::only('email', 'password');
$validator = \Validator::make($credentials, User::getApiAuthRules());
if ($validator->passes()) {
try {
if (!($token = \JWTAuth::attempt($credentials))) {
return \API::response()->array(['error' => 'invalid_credentials'])->statusCode(401);
}
} catch (JWTException $e) {
return \API::response()->array(['error' => 'could_not_create_token'])->statusCode(500);
}
} else {
throw new \Dingo\Api\Exception\StoreResourceFailedException('Could not signin.', $validator->errors());
}
return compact('token');
}
public function debug()
{
$passport['id'] = 0;
$passport['name'] = 'guest';
$passport['roles'] = ['guest'];
try {
$user = \JWTAuth::parseToken()->authenticate();
} catch (JWTException $e) {
$user = null;
}
if ($user) {
$passport['id'] = $user->getId();
$passport['name'] = $user->name;
$passport['roles'] = array_values($user->getRoles());
}
return response()->json($passport);
}
public function testChangePassword()
{
// Check authenticate
$res = $this->call('PUT', '/me/password');
$results = json_decode($res->getContent());
$this->assertEquals('error', $results->status);
$this->assertEquals('authenticate', $results->type);
$this->assertEquals('Token is not provided.', $results->message);
$credentials = ['email' => '*****@*****.**', 'password' => '123456'];
$token = JWTAuth::attempt($credentials);
// Input is empty
$res = $this->call('PUT', '/me/password', [], [], [], ['HTTP_Authorization' => "Bearer {$token}"]);
$this->assertEquals(400, $res->getStatusCode());
$results = json_decode($res->getContent());
$this->assertEquals('error', $results->status);
$this->assertEquals('validation', $results->type);
$this->assertObjectHasAttribute('old_password', $results->errors);
$this->assertEquals('The old password field is required.', $results->errors->old_password[0]);
$this->assertObjectHasAttribute('password', $results->errors);
$this->assertEquals('The password field is required.', $results->errors->password[0]);
// Check validate input
$res = $this->call('PUT', '/me/password', ['old_password' => '1234', 'password' => '1234', 'password_confirmation' => '123'], [], [], ['HTTP_Authorization' => "Bearer {$token}"]);
$this->assertEquals(400, $res->getStatusCode());
$results = json_decode($res->getContent());
$this->assertEquals('error', $results->status);
$this->assertEquals('validation', $results->type);
$this->assertObjectHasAttribute('old_password', $results->errors);
$this->assertEquals('The old password must be at least 6 characters.', $results->errors->old_password[0]);
$this->assertObjectHasAttribute('password', $results->errors);
$this->assertEquals('The password confirmation does not match.', $results->errors->password[0]);
$this->assertEquals('The password must be at least 6 characters.', $results->errors->password[1]);
// Old password is wrong
$res = $this->call('PUT', '/me/password', ['old_password' => '123456789', 'password' => '12345678', 'password_confirmation' => '12345678'], [], [], ['HTTP_Authorization' => "Bearer {$token}"]);
$this->assertEquals(400, $res->getStatusCode());
$results = json_decode($res->getContent());
$this->assertEquals('error', $results->status);
$this->assertEquals("The old password is incorrect.", $results->message);
$this->assertEquals('validation', $results->type);
// Change password success
$res = $this->call('PUT', '/me/password', ['old_password' => '123456', 'password' => '12345678', 'password_confirmation' => '12345678'], [], [], ['HTTP_Authorization' => "Bearer {$token}"]);
$this->assertEquals(204, $res->getStatusCode());
$checkPassword = Auth::attempt(['id' => 1, 'password' => '12345678']);
$this->assertTrue($checkPassword);
}
public function testWorkflow()
{
$customer = Customer::whereEmail('*****@*****.**')->first();
$customer->cart = null;
$customer->wishlist = null;
$token = JWTAuth::fromUser($customer);
//Initial get without login
$response = $this->call('GET', '/');
$app = app();
$shoppingCart = $app->settings->carts[Cart::SHOPPING_CART];
$this->assertEquals(0, count($shoppingCart->items));
$response = $this->action('POST', 'StoreController@addToCart', array('cart_type' => Cart::SHOPPING_CART, 'product_id' => 43, 'quantity' => 1));
$response = $this->call('GET', '/');
$response = $this->action('POST', 'StoreController@addToCart', array('cart_type' => Cart::SHOPPING_CART, 'product_id' => 44, 'quantity' => 1));
$this->assertEquals(2, count($shoppingCart->items));
//login
$response = $this->call('GET', '/', [], [], array('HTTP_authorization' => 'bearer ' . $token));
$this->assertEquals(2, count($shoppingCart->items));
}
public function authenticate(Request $request)
{
$credentials = $request->only('email', 'password');
try {
// verify the credentials and create a token for the user
if (!($token = \JWTAuth::attempt($credentials))) {
$response = new ApiResponse();
$response->status = 'error';
$response->message = ['id' => '', 'code' => 'invalid_credentials', 'description' => 'The credentials provided are not valid'];
return \Response::json($response);
}
} catch (JWTException $e) {
// something went wrong
$response = new ApiResponse();
$response->status = 'error';
$response->message = ['id' => '', 'code' => 'could_not_create_token', 'description' => 'The token could not be created'];
return \Response::json($response);
}
// if no errors are encountered we can return a JWT
$response = new ApiResponse();
$response->status = 'success';
$response->message = ['token' => $token];
return \Response::json($response);
}
/**
* Make a success response.
*
* @param \App\User $user
* @return \Illuminate\Http\JsonResponse
*/
protected function respondCreated(User $user)
{
return json()->setMeta(['token' => \JWTAuth::fromUser($user)])->created();
}
