public function inValidateToken()
{
$tempStorage = app('\\App\\Http\\Controllers\\TEMPStorage\\UserTempStorage');
$tempStorage->forget('id_company');
//set model login
$user = JWTAuth::parseToken()->authenticate();
$this->model->find($user->id)->update(['login' => 0]);
JWTAuth::invalidate(JWTAuth::getToken());
return API::response()->array(['message' => 'success'])->statusCode(200);
}
public function addPoint(Request $request)
{
$user = JWTAuth::parseToken()->authenticate();
$user->points = $user->points + $request->input('amount');
$user->save();
return response()->json(['success' => true, 'message' => "Users points added", 'users' => $user]);
}
protected function me()
{
if ($token = JWTAuth::getToken()) {
return JWTAuth::parseToken()->toUser();
}
return false;
}
public function __construct(User $user, Project $project, Invitation $invitation)
{
$this->loggedUser = JWTAuth::parseToken()->authenticate();
$this->user = $user;
$this->project = $project;
$this->invitation = $invitation;
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next, $aplicacion)
{
$metodo = $request->method();
$user = JWTAuth::parseToken()->authenticate();
switch ($metodo) {
case 'GET':
$tipo_permiso = 1;
break;
case 'POST':
$tipo_permiso = 2;
break;
case 'PUT':
$tipo_permiso = 2;
break;
case 'DELETE':
$tipo_permiso = 2;
break;
}
$privilegios = Privilegio::with('aplicacion')->where('user_id', $user->id)->where('aplicacion_id', $aplicacion);
if ($tipo_permiso == 1) {
$privilegios = $privilegios->where(function ($query) {
$query->where('privilegios_tipo_id', 1)->orWhere('privilegios_tipo_id', 2);
});
} else {
$privilegios = $privilegios->where('privilegios_tipo_id', $tipo_permiso);
}
$privilegios = $privilegios->first();
if ($privilegios) {
return $next($request);
} else {
return response('Unauthorized.', 401);
}
}
/**
* Permintaan refresh token
*
* @param Request $request
* @return array
*/
public function refreshToken(Request $request)
{
$this->middleware('auth');
$user = app('auth')->user();
$newToken = JWTAuth::parseToken()->refresh();
return ['status' => 'success', 'user' => $user, 'token' => $newToken];
}
public function destroy()
{
$user = JWTAuth::parseToken()->authenticate();
if ($user) {
User::destroy($user->id);
return response('Success');
} else {
return response('Unathorized', 403);
}
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @param int $level
* @return mixed
* @throws \Bican\Roles\Exceptions\LevelDeniedException
*/
public function handle($request, Closure $next, $level)
{
if (!($user = JWTAuth::parseToken()->authenticate())) {
return response()->json(['user_not_found'], 404);
}
if ($user->level() >= $level) {
return $next($request);
}
throw new LevelDeniedException($level);
}
public function currentUserIsOwner()
{
$user = JWTAuth::parseToken()->authenticate();
$user_id = $user->id;
if ($this->user_id == $user_id) {
return true;
} else {
return false;
}
}
protected function checkUserIsLogged()
{
$user = JWTAuth::parseToken()->authenticate();
if (!$user) {
return response()->json(["msg" => "You must be authenticated", "data" => false], 404);
} else {
$this->user = $user;
return true;
}
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
if (count(Enseignant_Privilege::where(function ($query) {
$query->where('id_Enseignant', '=', JWTAuth::parseToken()->toUser()->id_Enseignant)->where('id_Privilege', '=', '7');
})->get()) > 0) {
return $next($request);
} else {
return Response::json(['error' => 'Permission denied'], HttpResponse::HTTP_UNAUTHORIZED);
}
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @param int|string $permission
* @return mixed
* @throws \Sim\Roles\Exceptions\PermissionDeniedException
*/
public function handle($request, Closure $next, $permission)
{
if (!($user = JWTAuth::parseToken()->authenticate())) {
return response()->json(['user_not_found'], 404);
}
if ($user->can($permission)) {
return $next($request);
}
throw new PermissionDeniedException($permission);
}
public function destroy($id)
{
$user = JWTAuth::parseToken()->authenticate();
$todo = Todo::where('owner_id', $user->id)->where('id', $id)->first();
if ($todo) {
Todo::destroy($id);
return response('Success');
} else {
return response('Unathorized', 403);
}
}
public function edit_profile(Request $request)
{
$validator = Validator::make($request->all(), ['full_name' => 'required|max:50', 'user_name' => 'required|max:30', 'email' => 'required|email|max:50', 'address' => 'required|max:50']);
if ($validator->fails()) {
$data['errors'] = $validator->errors()->first();
return response()->json($data, 201);
}
$user = JWTAuth::parseToken()->authenticate();
$user = user::find($user->id);
$user->update($request->all());
$data['result'] = $user;
return response()->json($data, 200);
}
/**
* get his permission
*/
public function MenuRolePermission()
{
$user = JWTAuth::parseToken()->authenticate();
$this->id_role = $user->id_role;
$data = new \App\Api\Model\Menu();
$permission = \App\Api\Model\Permission::all();
foreach ($permission as $key => $value) {
$this->value = $value;
$data = $data->leftJoin('role_permissions as ' . $value->name, function ($join) {
$join->on(DB::raw($this->value->name . '.id_menu'), '=', 'menus.id')->where(DB::raw($this->value->name . '.id_role'), '=', $this->id_role)->where(DB::raw($this->value->name . '.id_permission'), '=', $this->value->id);
})->addSelect(DB::raw($value->name . '.id as ' . $value->name . 'ed'));
}
return $data->addSelect('menus.id', 'menus.name', 'menus.id_parent', 'menus.url', 'menus.icon', 'menus.order')->where('view.id', '>', '0')->orderBy('menus.id_parent')->orderBy('menus.order');
}
public function store(Request $request)
{
///validate data if it is in databse or not
$data_to_val = $request->only('product_codes');
$rule = AuctionController::getRule($request);
$user = JWTAuth::parseToken()->authenticate();
///if login
$validate = Validator::make($data_to_val, $rule);
if ($user->role != 1) {
return response()->json(['message', 'invalid Role']);
}
if ($validate->fails()) {
return response()->json($validate->errors()->all());
}
///open new auction
$auction = new Auction();
////add finished time this is added by 1 hr
$auction->finished_at = time() + 3600;
$auction->buyer()->associate($user);
$auction->save();
$products = [];
$product_codes = $request->get('product_codes');
foreach ($product_codes as $key => $val) {
$product = Product::where(['product_code' => $val])->get()->first();
$products[$key] = $product;
}
$auction->products()->saveMany($products);
if ($auction->products->count() >= 1) {
/////Generating Defualt Bid
foreach ($product_codes as $val) {
$product = Product::where(['product_code' => $val])->get()->first();
$product_descriptions = $product->product_descriptions;
$lowest_price_description = ProductController::findLowestPriceProductDescription($product_descriptions);
$bid = new Bid(['price' => $lowest_price_description->price]);
$bid->seller()->associate($lowest_price_description->seller);
$bid->auction()->associate($auction);
$bid->save();
$bid->products()->saveMany([$product]);
}
////
if ($auction->bids->count() >= 1) {
$auction->status = 0;
//opening
$auction->save();
return response()->json(['message', 'success']);
}
}
return response()->json(['message', 'error occurred']);
}
public function course($domain, $linkId, Request $request)
{
if ($request->token) {
$user = JWTAuth::parseToken()->authenticate();
$this->courseTransformer->setUser($user);
}
$courses = Course::all();
$return_data = new \stdClass();
foreach ($courses as $course) {
if ($linkId == convert_vi_to_en($course->name)) {
$return_data = $this->courseTransformer->transform($course);
}
}
return $this->respond($return_data);
}
/**
* Boot the authentication services for the application.
*
* @return void
*/
public function boot()
{
// Here you may define how you wish users to be authenticated for your Lumen
// application. The callback which receives the incoming request instance
// should return either a User instance or null. You're free to obtain
// the User instance via an API token or any other method necessary.
Auth::viaRequest('api', function ($request) {
try {
$playload = JWTAuth::parseToken()->getPayload();
return User::find($playload['sub']);
} catch (JWTException $e) {
return null;
}
});
}
public function getAuthenticatedUser()
{
try {
if (!($user = JWTAuth::parseToken()->authenticate())) {
return response()->json(['user_not_found'], 404);
}
} catch (TokenExpiredException $e) {
return response()->json(['token_expired'], $e->getStatusCode());
} catch (TokenInvalidException $e) {
return response()->json(['token_invalid'], $e->getStatusCode());
} catch (JWTException $e) {
return response()->json(['token_absent'], $e->getStatusCode());
}
return response()->json(compact('user'));
}
public function handle($request, Closure $next)
{
try {
if (!($user = JWTAuth::parseToken()->authenticate())) {
return redirect('login');
}
} catch (\Tymon\JWTAuth\Exceptions\TokenExpiredException $e) {
return redirect('login');
} catch (\Tymon\JWTAuth\Exceptions\TokenInvalidException $e) {
return redirect('login');
} catch (\Tymon\JWTAuth\Exceptions\JWTException $e) {
return redirect('login');
}
return $next($request);
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
try {
if (!JWTAuth::parseToken()->authenticate()) {
$data['error'] = "YOu are not logined";
return response()->json($data, 201);
}
} catch (TokenExpiredException $e) {
return response()->json($e->getMessage(), $e->getStatusCode());
} catch (TokenInvalidException $e) {
return response()->json($e->getMessage(), $e->getStatusCode());
} catch (JWTException $e) {
return response()->json($e->getMessage(), $e->getStatusCode());
}
return $next($request);
}
public function getAuthenticatedUser()
{
try {
if (!($user = JWTAuth::parseToken()->authenticate())) {
return response()->json(['usuário_não_encontrado'], 404);
}
} catch (TokenExpiredException $e) {
return response()->json(['token_expirado'], $e->getStatusCode());
} catch (TokenInvalidException $e) {
return response()->json(['token_inválido'], $e->getStatusCode());
} catch (JWTException $e) {
return response()->json(['token_ausente'], $e->getStatusCode());
}
// o token é válido e nós ter encontrado o utilizador através do sub reivindicação
return response()->json(compact('user'));
}
/**
* Returns the user that is currently authenticated on the system
* @return mixed
*/
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 handle($request, Closure $next)
{
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_invalid'], $e->getStatusCode());
}
// the token is valid and we have found the user via the sub claim
return $next($request);
}
/**
* List all industries
* @return Response
*/
public function index()
{
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
//$industry = Industry::latest()->get();
$industries = Industry::all();
return response()->json(compact('industries'));
}
public function postUpload(Request $request)
{
/** @var Ulibier $user */
$user = JWTAuth::parseToken()->authenticate();
$image = $request->file('image');
$photo_uptime = time();
$hash = uniqid($photo_uptime, true);
$imageFilename = $hash . '.' . $image->getClientOriginalExtension();
Storage::put('/imgtemp/' . $imageFilename, file_get_contents($image), 'public');
$photo = Photo::create();
$photo->photo_uptime = $photo_uptime;
$photo->photo_hash = $hash;
$photo->photo_extensions = $image->getClientOriginalExtension();
$photo->des_id = $request->input('des_id');
$photo->save();
$user->photos()->save($photo);
return $photo;
}
public function user_products($domain, $username, Request $request)
{
$target_user = User::where('username', $username)->first();
if ($target_user) {
if ($request->token) {
$user = JWTAuth::parseToken()->authenticate();
$this->productTransformer->setUser($user);
}
if ($request->limit) {
$limit = $request->limit;
} else {
$limit = 20;
}
$products = $target_user->products()->orderBy('created_at', 'desc')->paginate($limit);
return $this->respondWithPagination($products, ['products' => $this->productTransformer->transformCollection($products)]);
} else {
return $this->responseBadRequest("username not existed");
}
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
*/
public function handle($request, Closure $next)
{
if (!$request->header('Authorization')) {
return response()->json(['message' => 'You are not authorized'], 401);
}
try {
if (!($user = JWTAuth::parseToken()->authenticate())) {
return response()->json(['user_not_found'], 404);
}
} catch (TokenExpiredException $e) {
return response()->json(['token_expired'], $e->getStatusCode());
} catch (TokenInvalidException $e) {
return response()->json(['token_invalid'], $e->getStatusCode());
} catch (JWTException $e) {
return response()->json(['token_absent'], $e->getStatusCode());
}
$context = App::make('App\\Contexts\\Context');
$context->set($user);
return $next($request);
}
public function verifyEmail(Request $request)
{
// $payload = JWTAuth::parseToken()->getPayload();
// dd($payload->get(''));
$email = Cache::get($request->input('token'));
if ($email) {
$payload = JWTAuth::parseToken()->getPayload();
$user = User::whereEmail($email)->first();
// Create the user
if (!$user) {
$user = new User();
$user->email = $email;
$user->password = '******' . str_random(35);
}
$user->fellowship_one_user_id = $payload->get('fellowship_one_user_id');
$user->save();
$token = JWTAuth::fromUser($user, ['oauth_token' => $payload->get('oauth_token'), 'oauth_token_secret' => $payload->get('oauth_token_secret')]);
// TODO: Limit what is returned back in user object
return response()->json(compact('token', 'user'));
}
return response()->json(['message' => 'Validation email expired: ' . $email], 404);
// TODO:
}
/**
* @param Request $request
* @return null
* @throws Exceptions\JWTException
* @throws Exceptions\TokenExpiredException
* @throws Exceptions\TokenInvalidException
* @throws \Exception
*/
public static function checkUser($permissions)
{
$admin = ['Admin'];
$supervisor = ['Admin', 'Supervisor'];
$userPermissions = ['Admin', 'Supervisor', 'User'];
try {
if (!($user = JWTAuth::parseToken()->authenticate())) {
throw new Exceptions\JWTException();
}
if ($permissions != null) {
switch ($permissions) {
case 'User':
$validatePermissions = $userPermissions;
break;
case 'Supervisor':
$validatePermissions = $supervisor;
break;
case 'Admin':
$validatePermissions = $admin;
break;
default:
$validatePermissions = $userPermissions;
break;
}
if (!in_array($user->type, $validatePermissions)) {
throw new \App\Exceptions\UnauthorizedException();
}
}
return $user;
} catch (Exceptions\TokenExpiredException $e) {
throw $e;
} catch (Exceptions\TokenInvalidException $e) {
throw $e;
} catch (Exceptions\JWTException $e) {
throw $e;
}
}
