/**
* Handle a registration request for the application.
*
* @param \Illuminate\Http\Request $request
* @return \Illuminate\Http\Response
*/
public function postRegister(Request $request)
{
$validator = $this->validator($request->all());
if ($validator->fails()) {
$this->throwValidationException($request, $validator);
}
$token = JWTAuth::fromUser($this->create($request->all()), $this->customClaims());
$response = new JsonResponse(['token' => $token], 200);
$response->header('Authorization', 'Bearer ' . $token);
return $response;
}
public function index(FacebookAuthentication $request, FacebookGraphClient $client, FacebookUserResolver $resolver)
{
$data = $client->init($request->token)->getUser(['id', 'email', 'first_name', 'last_name']);
$user = $resolver->findOrCreateUser($data);
$customClaims = ['name' => $user->name, 'email' => $user->email, 'role' => $user->role, 'gravatar' => $user->gravatar];
return api_response(200, ['token' => JWTAuth::fromUser($user, $customClaims)]);
}
public function register(UserRequest $request)
{
$newUser = ['name' => $request->get('name'), 'email' => $request->get('email'), 'password' => bcrypt($request->get('password'))];
$user = User::create($newUser);
$token = JWTAuth::fromUser($user);
return response()->json(compact('token'));
}
public function register(RegisterRequest $request)
{
$newUser = ['email' => $request->get('email'), 'password' => Hash::make($request->get('password'))];
$user = $this->user->create($newUser);
$token = JWTAuth::fromUser($user);
return $this->apiResponse(200, ['message' => TOKEN_CREATED, 'token' => $token]);
}
public function postRegister(Request $request)
{
$validator = $this->validator($request->all());
if ($validator->fails()) {
$this->throwValidationException($request, $validator);
}
$token = JWTAuth::fromUser($this->create($request->all()));
return response()->json(['token' => $token]);
}
/**
* Return request headers needed to interact with the API.
*
* @return Array array of headers.
*/
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;
}
/**
* Store a newly created resource in storage.
*
* @return Response
*/
public function store(Request $request)
{
$user_created = $this->userRepository->create($request->all());
if ($user_created instanceof MessageBag) {
return response()->json($user_created)->setStatusCode(412, 'Invalid User');
}
$id = $user_created->id;
$token = JWTAuth::fromUser($user_created);
return response()->json(['id' => $id, 'uri' => url('profile', ['id' => $id])] + compact('token'))->setStatusCode(201);
}
public function postSignup(Request $request)
{
$credentials = $request->only('username', 'password');
try {
$user = Ulibier::create($credentials);
} catch (Exception $e) {
return response()->json(['error' => 'User already exists.'], 409);
}
$token = JWTAuth::fromUser($user);
return response()->json(compact('token'));
}
/**
* Handle the event.
*
* @param Login $event
* @return void
*/
public function handle(Login $event)
{
$tokenId = base64_encode(mcrypt_create_iv(32, MCRYPT_DEV_URANDOM));
$issuedAt = Carbon::now()->timestamp;
$notBefore = $issuedAt;
$expire = $notBefore + 6 * 60 * 60;
// Adding 6 hours
// Create the token
$config = ['iat' => $issuedAt, 'jti' => $tokenId, 'iss' => config('app.url'), 'nbf' => $notBefore, 'exp' => $expire, 'data' => ['userId' => $event->user->id]];
Session::put('jwt', JWTAuth::fromUser($event->user, $config));
}
public function signup()
{
$credentials = Input::only('email', 'password', 'name');
try {
$user = User::create($credentials);
} catch (Exception $e) {
return Response::json(['error' => 'User already exists.'], HttpResponse::HTTP_CONFLICT);
}
$token = JWTAuth::fromUser($user);
return Response::json(compact('token'));
}
/**
* Store a newly created User in storage.
*
* @param Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
Validator::make($request->all(), ['name' => 'required|max:255', 'email' => 'required|email|max:255|unique:users', 'password' => 'required|confirmed|min:6', 'role_id' => 'required|numeric']);
$user = User::create(['name' => $request['name'], 'email' => $request['email'], 'role_id' => $request['role_id'], 'password' => bcrypt($request['password'])]);
$user->jwt_token = JWTAuth::fromUser($user);
if ($user->save()) {
return response()->json(compact('user'));
} else {
$message = 'Something went wrong, please try again!';
return response()->json(compact('message'));
}
}
public function authenticate(Request $request)
{
$credentials = $request->only('email', 'password');
if (!Auth::attempt($credentials)) {
return response()->json(['error' => 'invalid_credentials'], 401);
}
$user = Auth::user();
$token = JWTAuth::fromUser($user);
$userData = ['name' => $user->name, 'admin' => $user->admin];
// if no errors are encountered we can return a JWT
return response()->json(compact('token', 'userData'));
}
public function register()
{
$email = Input::get('email');
$password = Hash::make(Input::get('password'));
try {
$user = User::create(['email' => $email, 'password' => $password]);
} catch (Exception $e) {
return Response::json(['error' => 'User already exists.'], HttpResponse::HTTP_CONFLICT);
}
$token = JWTAuth::fromUser($user);
return Response::json(compact('token'));
}
public function postForgot(Request $request)
{
$this->validate($request, ['email' => 'required|email']);
$user = User::where('email', $request->email)->first();
if (!$user) {
return redirect()->back()->withErrors(['email' => 'Your email address not registered.']);
}
$token = JWTAuth::fromUser($user);
$data = ['user' => $user, 'token' => $token];
Mail::send('emails.password', $data, function ($message) use($user) {
$message->from(env('MAIL_USERNAME'), env('APP_NAME'))->to($user->email, $user->fullname)->subject('Reset Password');
});
return redirect('auth/password/forgot')->withSuccess('Please check your email, we have sent request confirmation.');
}
protected function signup(Request $request)
{
$credentials = $request->only('email', 'password', 'name');
$credentials['password'] = bcrypt($credentials['password']);
try {
$user = User::create($credentials);
} catch (\Tymon\JWTAuth\Exceptions\JWTException $e) {
return response()->json(['error' => 'Could not create user.'], 409);
} catch (\QueryException $e) {
return response()->json(['error' => 'Email already exists.'], 409);
}
$token = JWTAuth::fromUser($user);
return response()->json(compact('token'));
}
public function signup(SignupRequest $request)
{
$credentials = $request->only('name', 'email', 'password');
$credentials['password'] = bcrypt($credentials['password']);
try {
if (User::where('email', '=', $credentials['email'])->count() < 1) {
$user = User::create($credentials);
} else {
return $this->response->withError('User already exists.', 409);
}
} catch (Exception $e) {
return $this->response->withError('User already exists.', 409);
}
$token = JWTAuth::fromUser($user);
return $this->response->array(['token' => $token, 'user' => $user->toArray()]);
}
/**
* Register a user
* @return Response
*/
public function register(Request $request)
{
//$credentials = $request->all();
//$credentials = $request->only('name', 'email', 'password');
try {
//$user = User::create($credentials);
$user = User::create(['name' => $request->input('name'), 'email' => $request->input('email'), 'password' => bcrypt($request->input('password'))]);
} catch (\Exception $e) {
//return response()->json(['error' => 'could_not_create_token'], HttpResponse::HTTP_CONFLICT);
return response()->json(['error' => 'User already exists'], HttpResponse::HTTP_CONFLICT);
}
$token = JWTAuth::fromUser($user);
//$industries = Industry::all();
$industries = Industry::select('id', 'slug', 'name')->get();
return response()->json(compact('token', 'industries'));
//return response()->json($credentials);
}
public function postAuth(Request $request)
{
$this->validate($request, ['platform' => 'required', 'udid' => 'required']);
$device = Device::where('udid', $request->input('udid'))->first();
if (is_null($device)) {
$country_code = $request->input('countryCode');
if (!$country_code) {
$country_code = Location::get($request->header('x-forwarded-for'), 'countryCode');
}
$device = new Device();
$device->fill($request->all());
$device->country_code = $country_code;
$device->save();
}
$device = Device::find($device->id);
$token = JWTAuth::fromUser($device);
return ['credits' => $device->credits, 'auth_token' => $token, 'sender_id' => env('GCM_SENDER_ID')];
}
/**
* Register any other events for your application.
*
* @param \Illuminate\Contracts\Events\Dispatcher $events
* @return void
* @SuppressWarnings(PHPMD.UnusedLocalVariable)
*/
public function boot(DispatcherContract $events)
{
parent::boot($events);
// On login, generate a JWT and store in the session
// FIXME: Regenerate if it expires?
$events->listen('auth.login', function ($user, $remember) {
$tokenId = base64_encode(mcrypt_create_iv(32, MCRYPT_DEV_URANDOM));
$issuedAt = Carbon::now()->timestamp;
$notBefore = $issuedAt;
$expire = $notBefore + 6 * 60 * 60;
// Adding 6 hours
// Create the token
$config = ['iat' => $issuedAt, 'jti' => $tokenId, 'iss' => env('APP_URL'), 'nbf' => $notBefore, 'exp' => $expire, 'data' => ['userId' => $user->id]];
Session::put('jwt', JWTAuth::fromUser($user, $config));
});
// On logout, removed the JWT from the session
$events->listen('auth.logout', function ($user) {
Session::forget('jwt');
});
}
public function authenticateOrCreateUser($profile)
{
# Figure out if a user exists by using the key (id) given by the provider
$user = User::where(['provider_key' => $profile['provider_key'], 'provider' => $profile['provider']])->first();
# If the user does not exist, create the user and return an API token
if (empty($user)) {
$user = new User();
$user->first_name = $profile['first_name'];
$user->last_name = $profile['last_name'];
$user->email = $profile['email'];
$user->provider = $profile['provider'];
$user->provider_key = $profile['provider_key'];
$user->avatar = $profile['avatar'];
$user->save();
$token = JWTAuth::fromUser($user);
return array('api-token' => $token, 'user' => $user);
} else {
$token = JWTAuth::fromUser($user);
return array('api-token' => $token, 'user' => $user);
}
}
public function register(Request $request)
{
$data = Input::get();
// Rate limit to 3 requests per 60 minutes
$throttler = Throttle::get($request, 3, 60);
if (!$throttler->attempt()) {
$response = Response(['error' => 'too many requests']);
$response->setStatusCode('420', "Enhance Your Calm");
return $response;
}
try {
$user = User::create(['username' => $data['username'], 'password' => Hash::make($data['password']), 'email' => $data['email'], 'name' => $data['name']]);
if (isset($data['gcm_token'])) {
$user->setGCMToken($data['gcm_token']);
$user->save();
}
} catch (\Exception $e) {
return new Response(['error' => true, "message" => $e->getMessage()], Response::HTTP_CONFLICT);
}
$token = JWTAuth::fromUser($user);
return ['error' => false, 'token' => $token];
}
/**
* Login with Facebook.
*/
public function facebook(Request $request)
{
$name = 'facebook';
if ($request->has('redirectUri')) {
config()->set("services.{$name}.redirect", $request->get('redirectUri'));
}
$provider = Socialite::driver($name);
$provider->stateless();
//$fb_profile = $provider->user();
// Step 1 + 2
try {
$fb_user = Socialite::driver('facebook')->user();
} catch (\Exception $e) {
//return redirect('auth/login')->withErrors(['error' => $e->getMessage()]); // http://localhost/pasu/public/auth/login
return response()->json(["error" => $e->getMessage()], 500);
}
// Handle the user etc.
// Step 3. Create a new user account or return an existing one.
$authUser = $this->findOrCreateUser($fb_user);
$token = JWTAuth::fromUser($auth_user);
return response()->json(compact('token'));
}
/**
* @api {post} /auth/signup 注册
*/
public function register(Request $request)
{
$validator = Validator::make($request->all(), ['username' => 'required|max:255|min:2', 'email' => 'required|email|unique:users', 'password' => 'required|min:6'], ['email.unique' => trans('demo.email_has_registed'), 'password.min' => '密码最少为6位字符']);
if ($validator->fails()) {
return $this->response->error($validator->messages(), 403);
}
//return $this->successResponse($request->only('username', 'email', 'password'));
// $data = [
// 'username' => $request->get('username'),
// 'email' => $request->get('email'),
// 'password' => bcrypt($request->get('username')),
// ];
// $user = User::create($data);
$user = new User();
$user->email = $request->get('email');
$user->username = $request->get('username');
$user->password = bcrypt($request->get('password'));
$user->group = $request->get('group');
$user->save();
// 用户注册事件
$token = JWTAuth::fromUser($user);
return response()->json(compact('token'));
}
public function refreshToken($domain)
{
$token = JWTAuth::fromUser($this->user);
return $this->respond(['token' => $token]);
}
public function transform(User $user)
{
return ['id' => $user->id, 'mobile' => $user->mobile ? preg_replace('/(1\\d{1,2})\\d\\d(\\d{0,2})/', '\\1****\\3', $user->mobile) : '', 'email' => $user->email, 'user_info' => $user->userInfo, 'user_token' => $user->userToken, 'token' => JWTAuth::fromUser($user)];
}
/**
* Generate new token by ID.
*
* @param mixed $id
*
* @return string|null
*/
public function generateTokenById($id)
{
if (!is_null($user = $this->provider->retrieveById($id))) {
return JWTAuth::fromUser($user);
}
return null;
}
/**
* Reset the given user's password.
*
* @param \Illuminate\Contracts\Auth\CanResetPassword $user
* @param string $password
* @return sttring
*/
protected function resetPassword($user, $password)
{
$user->password = bcrypt($password);
$user->save();
$token = JWTAuth::fromUser($user, $this->customClaims());
return $token;
}
public function getToken(User $user)
{
return JWTAuth::fromUser($user);
}
public function store_user($domain, Request $request)
{
$errors = [];
$user = User::where('email', '=', $request->email)->first();
if ($user) {
$errors['email'] = "Email đã có người sử dụng";
}
$username = trim($request->username);
$user = User::where('username', '=', $username)->first();
if ($user) {
$errors['username'] = "******";
}
if (!empty($errors)) {
return $this->responseBadRequest($errors);
}
$user = new User();
$user->name = $request->name;
$user->phone = $request->phone;
$user->email = $request->email;
$user->university = $request->school;
$user->work = $request->work;
$user->address = $request->address;
$user->how_know = $request->how_know;
$user->username = $username;
$user->facebook = $request->facebook;
$user->gender = $request->gender;
$user->dob = $request->dob;
$user->password = bcrypt($request->password);
$user->save();
$token = JWTAuth::fromUser($user);
return $this->respond(["user" => $user, 'token' => $token]);
}
/**
* Device Authentication login.
*
* @param DeviceLoginUserRequest $request
*
* @return Response
*
* @api {post} /v1/auth/devicelogin User Login with device
* @apiVersion 1.0.0
* @apiName AuthDeviceLogin
* @apiGroup Authentication
*
* @apiParam {String} id The unique device identifier.
*
* @apiSuccess {String} token Authentication token.
*
* @apiUse ApiLimitError
*/
public function deviceLogin(DeviceLoginUserRequest $request, LaravelFacebookSdk $fb)
{
$deviceId = $request->input('id');
$user = User::firstOrCreate(['device_id' => $deviceId, 'facebook_user_id' => 0]);
if ($user->name == '') {
// First connection, we generate a name
$guestCount = User::whereNotNull('device_id')->count();
// We add 50 to start from 50 and avoid like Guest 1 or guest 15, it can be frustrating
$guestCount += 50;
$user->name = 'Guest ' . $guestCount;
$user->save();
}
try {
if (!($token = JWTAuth::fromUser($user))) {
return $this->response->errorUnauthorized();
}
} catch (JWTException $e) {
return $this->response->error('could_not_create_token', 500);
}
return response()->json(compact('token'));
}
