2018-05-26 23:00:07 +00:00
|
|
|
<?php
|
|
|
|
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
|
2021-04-07 03:17:42 +00:00
|
|
|
use Auth;
|
|
|
|
use Cache;
|
|
|
|
use Mail;
|
2019-12-11 06:04:03 +00:00
|
|
|
use Illuminate\Support\Facades\Redis;
|
2020-01-29 06:37:08 +00:00
|
|
|
use Illuminate\Support\Str;
|
2018-08-28 03:07:36 +00:00
|
|
|
use Carbon\Carbon;
|
2019-07-11 05:10:00 +00:00
|
|
|
use App\Mail\ConfirmEmail;
|
2018-08-28 03:07:36 +00:00
|
|
|
use Illuminate\Http\Request;
|
2018-09-16 05:15:45 +00:00
|
|
|
use PragmaRX\Google2FA\Google2FA;
|
2019-07-11 05:10:00 +00:00
|
|
|
use App\Jobs\FollowPipeline\FollowPipeline;
|
|
|
|
use App\{
|
2020-11-18 21:19:02 +00:00
|
|
|
DirectMessage,
|
2019-07-11 05:10:00 +00:00
|
|
|
EmailVerification,
|
|
|
|
Follower,
|
|
|
|
FollowRequest,
|
2023-03-01 11:16:42 +00:00
|
|
|
Media,
|
2019-07-11 05:10:00 +00:00
|
|
|
Notification,
|
|
|
|
Profile,
|
|
|
|
User,
|
2023-03-01 11:16:42 +00:00
|
|
|
UserDevice,
|
|
|
|
UserFilter,
|
|
|
|
UserSetting
|
2019-07-11 05:10:00 +00:00
|
|
|
};
|
2021-01-31 20:45:22 +00:00
|
|
|
use League\Fractal;
|
|
|
|
use League\Fractal\Serializer\ArraySerializer;
|
|
|
|
use League\Fractal\Pagination\IlluminatePaginatorAdapter;
|
|
|
|
use App\Transformer\Api\Mastodon\v1\AccountTransformer;
|
2021-10-20 10:31:07 +00:00
|
|
|
use App\Services\AccountService;
|
2023-04-20 11:27:44 +00:00
|
|
|
use App\Services\FollowerService;
|
2023-03-01 11:16:42 +00:00
|
|
|
use App\Services\NotificationService;
|
2021-10-20 10:31:07 +00:00
|
|
|
use App\Services\UserFilterService;
|
2022-01-06 08:05:11 +00:00
|
|
|
use App\Services\RelationshipService;
|
2022-06-03 10:18:06 +00:00
|
|
|
use App\Jobs\FollowPipeline\FollowAcceptPipeline;
|
2022-06-11 09:27:52 +00:00
|
|
|
use App\Jobs\FollowPipeline\FollowRejectPipeline;
|
2018-05-26 23:00:07 +00:00
|
|
|
|
|
|
|
class AccountController extends Controller
|
|
|
|
{
|
2019-07-11 05:10:00 +00:00
|
|
|
protected $filters = [
|
|
|
|
'user.mute',
|
|
|
|
'user.block',
|
|
|
|
];
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
const FILTER_LIMIT_MUTE_TEXT = 'You cannot mute more than ';
|
|
|
|
const FILTER_LIMIT_BLOCK_TEXT = 'You cannot block more than ';
|
2021-10-20 10:31:07 +00:00
|
|
|
|
2019-07-11 05:10:00 +00:00
|
|
|
public function __construct()
|
|
|
|
{
|
|
|
|
$this->middleware('auth');
|
|
|
|
}
|
|
|
|
|
|
|
|
public function notifications(Request $request)
|
|
|
|
{
|
|
|
|
return view('account.activity');
|
|
|
|
}
|
|
|
|
|
|
|
|
public function followingActivity(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
|
|
|
'page' => 'nullable|min:1|max:3',
|
|
|
|
'a' => 'nullable|alpha_dash',
|
|
|
|
]);
|
|
|
|
|
|
|
|
$action = $request->input('a');
|
|
|
|
$allowed = ['like', 'follow'];
|
|
|
|
$timeago = Carbon::now()->subMonths(3);
|
|
|
|
|
|
|
|
$profile = Auth::user()->profile;
|
|
|
|
$following = $profile->following->pluck('id');
|
|
|
|
|
|
|
|
$notifications = Notification::whereIn('actor_id', $following)
|
|
|
|
->whereIn('action', $allowed)
|
|
|
|
->where('actor_id', '<>', $profile->id)
|
|
|
|
->where('profile_id', '<>', $profile->id)
|
|
|
|
->whereDate('created_at', '>', $timeago)
|
|
|
|
->orderBy('notifications.created_at', 'desc')
|
|
|
|
->simplePaginate(30);
|
|
|
|
|
|
|
|
return view('account.following', compact('profile', 'notifications'));
|
|
|
|
}
|
|
|
|
|
|
|
|
public function verifyEmail(Request $request)
|
|
|
|
{
|
2021-11-09 06:13:10 +00:00
|
|
|
$recentSent = EmailVerification::whereUserId(Auth::id())
|
|
|
|
->whereDate('created_at', '>', now()->subHours(12))->count();
|
|
|
|
|
|
|
|
return view('account.verify_email', compact('recentSent'));
|
2019-07-11 05:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public function sendVerifyEmail(Request $request)
|
|
|
|
{
|
|
|
|
$recentAttempt = EmailVerification::whereUserId(Auth::id())
|
|
|
|
->whereDate('created_at', '>', now()->subHours(12))->count();
|
|
|
|
|
|
|
|
if ($recentAttempt > 0) {
|
|
|
|
return redirect()->back()->with('error', 'A verification email has already been sent recently. Please check your email, or try again later.');
|
2021-04-07 03:17:42 +00:00
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
|
|
|
|
EmailVerification::whereUserId(Auth::id())->delete();
|
|
|
|
|
|
|
|
$user = User::whereNull('email_verified_at')->find(Auth::id());
|
2020-01-29 06:37:08 +00:00
|
|
|
$utoken = Str::uuid() . Str::random(mt_rand(5,9));
|
|
|
|
$rtoken = Str::random(mt_rand(64, 70));
|
2019-07-11 05:10:00 +00:00
|
|
|
|
|
|
|
$verify = new EmailVerification();
|
|
|
|
$verify->user_id = $user->id;
|
|
|
|
$verify->email = $user->email;
|
|
|
|
$verify->user_token = $utoken;
|
|
|
|
$verify->random_token = $rtoken;
|
|
|
|
$verify->save();
|
|
|
|
|
|
|
|
Mail::to($user->email)->send(new ConfirmEmail($verify));
|
|
|
|
|
|
|
|
return redirect()->back()->with('status', 'Verification email sent!');
|
|
|
|
}
|
|
|
|
|
|
|
|
public function confirmVerifyEmail(Request $request, $userToken, $randomToken)
|
|
|
|
{
|
|
|
|
$verify = EmailVerification::where('user_token', $userToken)
|
2020-01-29 06:37:08 +00:00
|
|
|
->where('created_at', '>', now()->subHours(24))
|
2019-07-11 05:10:00 +00:00
|
|
|
->where('random_token', $randomToken)
|
|
|
|
->firstOrFail();
|
|
|
|
|
|
|
|
if (Auth::id() === $verify->user_id && $verify->user_token === $userToken && $verify->random_token === $randomToken) {
|
|
|
|
$user = User::find(Auth::id());
|
|
|
|
$user->email_verified_at = Carbon::now();
|
|
|
|
$user->save();
|
|
|
|
|
|
|
|
return redirect('/');
|
|
|
|
} else {
|
|
|
|
abort(403);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public function direct()
|
|
|
|
{
|
|
|
|
return view('account.direct');
|
|
|
|
}
|
|
|
|
|
2020-11-18 21:19:02 +00:00
|
|
|
public function directMessage(Request $request, $id)
|
2019-07-11 05:10:00 +00:00
|
|
|
{
|
2020-11-18 21:19:02 +00:00
|
|
|
$profile = Profile::where('id', '!=', $request->user()->profile_id)
|
|
|
|
// ->whereNull('domain')
|
|
|
|
->findOrFail($id);
|
|
|
|
return view('account.directmessage', compact('id'));
|
2019-07-11 05:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public function mute(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
2023-03-01 11:16:42 +00:00
|
|
|
'type' => 'required|string|in:user',
|
2019-07-11 05:10:00 +00:00
|
|
|
'item' => 'required|integer|min:1',
|
|
|
|
]);
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
$pid = $request->user()->profile_id;
|
|
|
|
$count = UserFilterService::muteCount($pid);
|
|
|
|
$maxLimit = intval(config('instance.user_filters.max_user_mutes'));
|
|
|
|
abort_if($count >= $maxLimit, 422, self::FILTER_LIMIT_MUTE_TEXT . $maxLimit . ' accounts');
|
2021-10-20 10:31:07 +00:00
|
|
|
if($count == 0) {
|
2023-03-01 11:16:42 +00:00
|
|
|
$filterCount = UserFilter::whereUserId($pid)->count();
|
|
|
|
abort_if($filterCount >= $maxLimit, 422, self::FILTER_LIMIT_MUTE_TEXT . $maxLimit . ' accounts');
|
2021-10-20 10:31:07 +00:00
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
$type = $request->input('type');
|
|
|
|
$item = $request->input('item');
|
|
|
|
$action = $type . '.mute';
|
|
|
|
|
|
|
|
if (!in_array($action, $this->filters)) {
|
|
|
|
return abort(406);
|
|
|
|
}
|
|
|
|
$filterable = [];
|
|
|
|
switch ($type) {
|
|
|
|
case 'user':
|
|
|
|
$profile = Profile::findOrFail($item);
|
2023-03-01 11:16:42 +00:00
|
|
|
if ($profile->id == $pid) {
|
2019-07-11 05:10:00 +00:00
|
|
|
return abort(403);
|
|
|
|
}
|
|
|
|
$class = get_class($profile);
|
|
|
|
$filterable['id'] = $profile->id;
|
|
|
|
$filterable['type'] = $class;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
$filter = UserFilter::firstOrCreate([
|
2023-03-01 11:16:42 +00:00
|
|
|
'user_id' => $pid,
|
2019-07-11 05:10:00 +00:00
|
|
|
'filterable_id' => $filterable['id'],
|
|
|
|
'filterable_type' => $filterable['type'],
|
|
|
|
'filter_type' => 'mute',
|
|
|
|
]);
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
UserFilterService::mute($pid, $filterable['id']);
|
|
|
|
$res = RelationshipService::refresh($pid, $profile->id);
|
2019-07-11 05:10:00 +00:00
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
if($request->wantsJson()) {
|
|
|
|
return response()->json($res);
|
|
|
|
} else {
|
|
|
|
return redirect()->back();
|
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public function unmute(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
2023-03-01 11:16:42 +00:00
|
|
|
'type' => 'required|string|in:user',
|
2019-07-11 05:10:00 +00:00
|
|
|
'item' => 'required|integer|min:1',
|
|
|
|
]);
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
$pid = $request->user()->profile_id;
|
2019-07-11 05:10:00 +00:00
|
|
|
$type = $request->input('type');
|
|
|
|
$item = $request->input('item');
|
|
|
|
$action = $type . '.mute';
|
|
|
|
|
|
|
|
if (!in_array($action, $this->filters)) {
|
|
|
|
return abort(406);
|
|
|
|
}
|
|
|
|
$filterable = [];
|
|
|
|
switch ($type) {
|
|
|
|
case 'user':
|
|
|
|
$profile = Profile::findOrFail($item);
|
2023-03-01 11:16:42 +00:00
|
|
|
if ($profile->id == $pid) {
|
2019-07-11 05:10:00 +00:00
|
|
|
return abort(403);
|
|
|
|
}
|
|
|
|
$class = get_class($profile);
|
|
|
|
$filterable['id'] = $profile->id;
|
|
|
|
$filterable['type'] = $class;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort(400);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
$filter = UserFilter::whereUserId($pid)
|
2019-07-11 05:10:00 +00:00
|
|
|
->whereFilterableId($filterable['id'])
|
|
|
|
->whereFilterableType($filterable['type'])
|
|
|
|
->whereFilterType('mute')
|
|
|
|
->first();
|
|
|
|
|
|
|
|
if($filter) {
|
2023-03-01 11:16:42 +00:00
|
|
|
UserFilterService::unmute($pid, $filterable['id']);
|
2019-07-11 05:10:00 +00:00
|
|
|
$filter->delete();
|
|
|
|
}
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
$res = RelationshipService::refresh($pid, $profile->id);
|
2019-07-11 05:10:00 +00:00
|
|
|
|
|
|
|
if($request->wantsJson()) {
|
2023-03-01 11:16:42 +00:00
|
|
|
return response()->json($res);
|
2019-07-11 05:10:00 +00:00
|
|
|
} else {
|
|
|
|
return redirect()->back();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public function block(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
2023-03-01 11:16:42 +00:00
|
|
|
'type' => 'required|string|in:user',
|
2019-07-11 05:10:00 +00:00
|
|
|
'item' => 'required|integer|min:1',
|
|
|
|
]);
|
2023-03-01 11:16:42 +00:00
|
|
|
$pid = $request->user()->profile_id;
|
|
|
|
$count = UserFilterService::blockCount($pid);
|
|
|
|
$maxLimit = intval(config('instance.user_filters.max_user_blocks'));
|
|
|
|
abort_if($count >= $maxLimit, 422, self::FILTER_LIMIT_BLOCK_TEXT . $maxLimit . ' accounts');
|
2021-10-20 10:31:07 +00:00
|
|
|
if($count == 0) {
|
2023-03-01 11:16:42 +00:00
|
|
|
$filterCount = UserFilter::whereUserId($pid)->whereFilterType('block')->count();
|
|
|
|
abort_if($filterCount >= $maxLimit, 422, self::FILTER_LIMIT_BLOCK_TEXT . $maxLimit . ' accounts');
|
2021-10-20 10:31:07 +00:00
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
$type = $request->input('type');
|
|
|
|
$item = $request->input('item');
|
|
|
|
$action = $type.'.block';
|
|
|
|
if (!in_array($action, $this->filters)) {
|
|
|
|
return abort(406);
|
|
|
|
}
|
|
|
|
$filterable = [];
|
|
|
|
switch ($type) {
|
|
|
|
case 'user':
|
|
|
|
$profile = Profile::findOrFail($item);
|
2023-03-01 11:16:42 +00:00
|
|
|
if ($profile->id == $pid || ($profile->user && $profile->user->is_admin == true)) {
|
2019-07-11 05:10:00 +00:00
|
|
|
return abort(403);
|
|
|
|
}
|
|
|
|
$class = get_class($profile);
|
|
|
|
$filterable['id'] = $profile->id;
|
|
|
|
$filterable['type'] = $class;
|
|
|
|
|
2023-04-20 00:57:40 +00:00
|
|
|
$followed = Follower::whereProfileId($profile->id)->whereFollowingId($pid)->first();
|
|
|
|
if($followed) {
|
|
|
|
$followed->delete();
|
2023-04-20 11:27:44 +00:00
|
|
|
$profile->following_count = Follower::whereProfileId($profile->id)->count();
|
|
|
|
$profile->save();
|
2023-04-20 00:57:40 +00:00
|
|
|
$selfProfile = $request->user()->profile;
|
|
|
|
$selfProfile->followers_count = Follower::whereFollowingId($pid)->count();
|
|
|
|
$selfProfile->save();
|
2023-04-20 11:27:44 +00:00
|
|
|
FollowerService::remove($profile->id, $pid);
|
|
|
|
AccountService::del($pid);
|
|
|
|
AccountService::del($profile->id);
|
|
|
|
}
|
|
|
|
|
|
|
|
$following = Follower::whereProfileId($pid)->whereFollowingId($profile->id)->first();
|
|
|
|
if($following) {
|
|
|
|
$following->delete();
|
|
|
|
$profile->followers_count = Follower::whereFollowingId($profile->id)->count();
|
|
|
|
$profile->save();
|
|
|
|
$selfProfile = $request->user()->profile;
|
|
|
|
$selfProfile->following_count = Follower::whereProfileId($pid)->count();
|
|
|
|
$selfProfile->save();
|
|
|
|
FollowerService::remove($pid, $profile->pid);
|
|
|
|
AccountService::del($pid);
|
|
|
|
AccountService::del($profile->id);
|
2023-04-20 00:57:40 +00:00
|
|
|
}
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
Notification::whereProfileId($pid)
|
|
|
|
->whereActorId($profile->id)
|
|
|
|
->get()
|
|
|
|
->map(function($n) use($pid) {
|
|
|
|
NotificationService::del($pid, $n['id']);
|
|
|
|
$n->forceDelete();
|
2023-04-20 00:57:40 +00:00
|
|
|
});
|
2019-07-11 05:10:00 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
$filter = UserFilter::firstOrCreate([
|
2023-03-01 11:16:42 +00:00
|
|
|
'user_id' => $pid,
|
2019-07-11 05:10:00 +00:00
|
|
|
'filterable_id' => $filterable['id'],
|
|
|
|
'filterable_type' => $filterable['type'],
|
|
|
|
'filter_type' => 'block',
|
|
|
|
]);
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
UserFilterService::block($pid, $filterable['id']);
|
|
|
|
$res = RelationshipService::refresh($pid, $profile->id);
|
2019-07-11 05:10:00 +00:00
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
if($request->wantsJson()) {
|
|
|
|
return response()->json($res);
|
|
|
|
} else {
|
|
|
|
return redirect()->back();
|
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public function unblock(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
2023-03-01 11:16:42 +00:00
|
|
|
'type' => 'required|string|in:user',
|
2019-07-11 05:10:00 +00:00
|
|
|
'item' => 'required|integer|min:1',
|
|
|
|
]);
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
$pid = $request->user()->profile_id;
|
2019-07-11 05:10:00 +00:00
|
|
|
$type = $request->input('type');
|
|
|
|
$item = $request->input('item');
|
|
|
|
$action = $type . '.block';
|
|
|
|
if (!in_array($action, $this->filters)) {
|
|
|
|
return abort(406);
|
|
|
|
}
|
|
|
|
$filterable = [];
|
|
|
|
switch ($type) {
|
|
|
|
case 'user':
|
|
|
|
$profile = Profile::findOrFail($item);
|
2023-03-01 11:16:42 +00:00
|
|
|
if ($profile->id == $pid) {
|
2019-07-11 05:10:00 +00:00
|
|
|
return abort(403);
|
|
|
|
}
|
|
|
|
$class = get_class($profile);
|
|
|
|
$filterable['id'] = $profile->id;
|
|
|
|
$filterable['type'] = $class;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort(400);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
$filter = UserFilter::whereUserId($pid)
|
2019-07-11 05:10:00 +00:00
|
|
|
->whereFilterableId($filterable['id'])
|
|
|
|
->whereFilterableType($filterable['type'])
|
|
|
|
->whereFilterType('block')
|
|
|
|
->first();
|
|
|
|
|
|
|
|
if($filter) {
|
|
|
|
$filter->delete();
|
2023-04-20 11:27:44 +00:00
|
|
|
UserFilterService::unblock($pid, $filterable['id']);
|
2019-07-11 05:10:00 +00:00
|
|
|
}
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
$res = RelationshipService::refresh($pid, $profile->id);
|
2019-07-11 05:10:00 +00:00
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
if($request->wantsJson()) {
|
|
|
|
return response()->json($res);
|
|
|
|
} else {
|
|
|
|
return redirect()->back();
|
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public function followRequests(Request $request)
|
|
|
|
{
|
|
|
|
$pid = Auth::user()->profile->id;
|
|
|
|
$followers = FollowRequest::whereFollowingId($pid)->orderBy('id','desc')->whereIsRejected(0)->simplePaginate(10);
|
|
|
|
return view('account.follow-requests', compact('followers'));
|
|
|
|
}
|
|
|
|
|
2020-04-27 05:20:27 +00:00
|
|
|
public function followRequestsJson(Request $request)
|
|
|
|
{
|
|
|
|
$pid = Auth::user()->profile_id;
|
|
|
|
$followers = FollowRequest::whereFollowingId($pid)->orderBy('id','desc')->whereIsRejected(0)->get();
|
|
|
|
$res = [
|
|
|
|
'count' => $followers->count(),
|
|
|
|
'accounts' => $followers->take(10)->map(function($a) {
|
|
|
|
$actor = $a->actor;
|
|
|
|
return [
|
2022-06-03 10:28:58 +00:00
|
|
|
'rid' => (string) $a->id,
|
|
|
|
'id' => (string) $actor->id,
|
2020-04-27 05:20:27 +00:00
|
|
|
'username' => $actor->username,
|
|
|
|
'avatar' => $actor->avatarUrl(),
|
|
|
|
'url' => $actor->url(),
|
|
|
|
'local' => $actor->domain == null,
|
2022-06-11 06:37:36 +00:00
|
|
|
'account' => AccountService::get($actor->id)
|
2020-04-27 05:20:27 +00:00
|
|
|
];
|
|
|
|
})
|
|
|
|
];
|
|
|
|
return response()->json($res, 200, [], JSON_PRETTY_PRINT|JSON_UNESCAPED_SLASHES);
|
|
|
|
}
|
|
|
|
|
2019-07-11 05:10:00 +00:00
|
|
|
public function followRequestHandle(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
|
|
|
'action' => 'required|string|max:10',
|
|
|
|
'id' => 'required|integer|min:1'
|
|
|
|
]);
|
|
|
|
|
|
|
|
$pid = Auth::user()->profile->id;
|
|
|
|
$action = $request->input('action') === 'accept' ? 'accept' : 'reject';
|
|
|
|
$id = $request->input('id');
|
|
|
|
$followRequest = FollowRequest::whereFollowingId($pid)->findOrFail($id);
|
|
|
|
$follower = $followRequest->follower;
|
|
|
|
|
|
|
|
switch ($action) {
|
|
|
|
case 'accept':
|
2022-06-11 11:16:38 +00:00
|
|
|
$follow = new Follower();
|
|
|
|
$follow->profile_id = $follower->id;
|
|
|
|
$follow->following_id = $pid;
|
|
|
|
$follow->save();
|
|
|
|
|
|
|
|
$profile = Profile::findOrFail($pid);
|
|
|
|
$profile->followers_count++;
|
|
|
|
$profile->save();
|
|
|
|
AccountService::del($profile->id);
|
|
|
|
|
|
|
|
$profile = Profile::findOrFail($follower->id);
|
|
|
|
$profile->following_count++;
|
|
|
|
$profile->save();
|
|
|
|
AccountService::del($profile->id);
|
|
|
|
|
|
|
|
if($follower->domain != null && $follower->private_key === null) {
|
2022-12-13 03:43:51 +00:00
|
|
|
FollowAcceptPipeline::dispatch($followRequest)->onQueue('follow');
|
2022-06-11 11:16:38 +00:00
|
|
|
} else {
|
|
|
|
FollowPipeline::dispatch($follow);
|
|
|
|
$followRequest->delete();
|
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'reject':
|
2022-06-11 09:27:52 +00:00
|
|
|
if($follower->domain != null && $follower->private_key === null) {
|
2022-12-13 03:43:51 +00:00
|
|
|
FollowRejectPipeline::dispatch($followRequest)->onQueue('follow');
|
2022-06-11 09:27:52 +00:00
|
|
|
} else {
|
|
|
|
$followRequest->delete();
|
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-12-11 05:58:13 +00:00
|
|
|
Cache::forget('profile:follower_count:'.$pid);
|
|
|
|
Cache::forget('profile:following_count:'.$pid);
|
2022-03-06 10:45:19 +00:00
|
|
|
RelationshipService::refresh($pid, $follower->id);
|
2020-12-11 05:58:13 +00:00
|
|
|
|
2019-07-11 05:10:00 +00:00
|
|
|
return response()->json(['msg' => 'success'], 200);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function sudoMode(Request $request)
|
|
|
|
{
|
2020-02-18 06:16:44 +00:00
|
|
|
if($request->session()->has('sudoModeAttempts') && $request->session()->get('sudoModeAttempts') >= 3) {
|
|
|
|
$request->session()->pull('2fa.session.active');
|
|
|
|
$request->session()->pull('redirectNext');
|
|
|
|
$request->session()->pull('sudoModeAttempts');
|
|
|
|
Auth::logout();
|
|
|
|
return redirect(route('login'));
|
2021-04-07 03:17:42 +00:00
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
return view('auth.sudo');
|
|
|
|
}
|
|
|
|
|
|
|
|
public function sudoModeVerify(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
2020-03-15 04:35:35 +00:00
|
|
|
'password' => 'required|string|max:500',
|
|
|
|
'trustDevice' => 'nullable'
|
2019-07-11 05:10:00 +00:00
|
|
|
]);
|
2020-03-15 04:35:35 +00:00
|
|
|
|
2019-07-11 05:10:00 +00:00
|
|
|
$user = Auth::user();
|
|
|
|
$password = $request->input('password');
|
2020-03-15 04:35:35 +00:00
|
|
|
$trustDevice = $request->input('trustDevice') == 'on';
|
2019-07-11 05:10:00 +00:00
|
|
|
$next = $request->session()->get('redirectNext', '/');
|
2020-02-18 06:16:44 +00:00
|
|
|
if($request->session()->has('sudoModeAttempts')) {
|
|
|
|
$count = (int) $request->session()->get('sudoModeAttempts');
|
|
|
|
$request->session()->put('sudoModeAttempts', $count + 1);
|
|
|
|
} else {
|
|
|
|
$request->session()->put('sudoModeAttempts', 1);
|
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
if(password_verify($password, $user->password) === true) {
|
|
|
|
$request->session()->put('sudoMode', time());
|
2020-03-15 04:35:35 +00:00
|
|
|
if($trustDevice == true) {
|
|
|
|
$request->session()->put('sudoTrustDevice', 1);
|
|
|
|
}
|
2022-12-03 19:43:51 +00:00
|
|
|
|
|
|
|
//Fix wrong scheme when using reverse proxy
|
|
|
|
if(!str_contains($next, 'https') && config('instance.force_https_urls', true)) {
|
|
|
|
$next = Str::of($next)->replace('http', 'https')->toString();
|
|
|
|
}
|
|
|
|
|
2019-07-11 05:10:00 +00:00
|
|
|
return redirect($next);
|
|
|
|
} else {
|
|
|
|
return redirect()
|
|
|
|
->back()
|
|
|
|
->withErrors(['password' => __('auth.failed')]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public function twoFactorCheckpoint(Request $request)
|
|
|
|
{
|
|
|
|
return view('auth.checkpoint');
|
|
|
|
}
|
|
|
|
|
|
|
|
public function twoFactorVerify(Request $request)
|
|
|
|
{
|
|
|
|
$this->validate($request, [
|
|
|
|
'code' => 'required|string|max:32'
|
|
|
|
]);
|
|
|
|
$user = Auth::user();
|
|
|
|
$code = $request->input('code');
|
|
|
|
$google2fa = new Google2FA();
|
|
|
|
$verify = $google2fa->verifyKey($user->{'2fa_secret'}, $code);
|
|
|
|
if($verify) {
|
|
|
|
$request->session()->push('2fa.session.active', true);
|
|
|
|
return redirect('/');
|
|
|
|
} else {
|
|
|
|
|
|
|
|
if($this->twoFactorBackupCheck($request, $code, $user)) {
|
|
|
|
return redirect('/');
|
|
|
|
}
|
|
|
|
|
|
|
|
if($request->session()->has('2fa.attempts')) {
|
2020-05-24 08:04:53 +00:00
|
|
|
$count = (int) $request->session()->get('2fa.attempts');
|
|
|
|
if($count == 3) {
|
|
|
|
Auth::logout();
|
|
|
|
return redirect('/');
|
|
|
|
}
|
|
|
|
$request->session()->put('2fa.attempts', $count + 1);
|
2019-07-11 05:10:00 +00:00
|
|
|
} else {
|
2020-05-24 08:04:53 +00:00
|
|
|
$request->session()->put('2fa.attempts', 1);
|
2019-07-11 05:10:00 +00:00
|
|
|
}
|
2020-05-24 08:04:53 +00:00
|
|
|
return redirect('/i/auth/checkpoint')->withErrors([
|
2019-07-11 05:10:00 +00:00
|
|
|
'code' => 'Invalid code'
|
|
|
|
]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-01 11:16:42 +00:00
|
|
|
protected function twoFactorBackupCheck($request, $code, User $user)
|
|
|
|
{
|
|
|
|
$backupCodes = $user->{'2fa_backup_codes'};
|
|
|
|
if($backupCodes) {
|
|
|
|
$codes = json_decode($backupCodes, true);
|
|
|
|
foreach ($codes as $c) {
|
|
|
|
if(hash_equals($c, $code)) {
|
|
|
|
$codes = array_flatten(array_diff($codes, [$code]));
|
|
|
|
$user->{'2fa_backup_codes'} = json_encode($codes);
|
|
|
|
$user->save();
|
|
|
|
$request->session()->push('2fa.session.active', true);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
2022-11-14 08:17:41 +00:00
|
|
|
return false;
|
2023-03-01 11:16:42 +00:00
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2019-07-11 05:10:00 +00:00
|
|
|
|
|
|
|
public function accountRestored(Request $request)
|
|
|
|
{
|
|
|
|
}
|
2021-01-31 20:45:22 +00:00
|
|
|
|
|
|
|
public function accountMutes(Request $request)
|
|
|
|
{
|
|
|
|
abort_if(!$request->user(), 403);
|
|
|
|
|
|
|
|
$this->validate($request, [
|
|
|
|
'limit' => 'nullable|integer|min:1|max:40'
|
|
|
|
]);
|
|
|
|
|
|
|
|
$user = $request->user();
|
|
|
|
$limit = $request->input('limit') ?? 40;
|
|
|
|
|
|
|
|
$mutes = UserFilter::whereUserId($user->profile_id)
|
|
|
|
->whereFilterableType('App\Profile')
|
|
|
|
->whereFilterType('mute')
|
|
|
|
->simplePaginate($limit)
|
|
|
|
->pluck('filterable_id');
|
|
|
|
|
|
|
|
$accounts = Profile::find($mutes);
|
|
|
|
$fractal = new Fractal\Manager();
|
|
|
|
$fractal->setSerializer(new ArraySerializer());
|
|
|
|
$resource = new Fractal\Resource\Collection($accounts, new AccountTransformer());
|
|
|
|
$res = $fractal->createData($resource)->toArray();
|
|
|
|
$url = $request->url();
|
|
|
|
$page = $request->input('page', 1);
|
|
|
|
$next = $page < 40 ? $page + 1 : 40;
|
|
|
|
$prev = $page > 1 ? $page - 1 : 1;
|
|
|
|
$links = '<'.$url.'?page='.$next.'&limit='.$limit.'>; rel="next", <'.$url.'?page='.$prev.'&limit='.$limit.'>; rel="prev"';
|
|
|
|
return response()->json($res, 200, ['Link' => $links]);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function accountBlocks(Request $request)
|
|
|
|
{
|
|
|
|
abort_if(!$request->user(), 403);
|
|
|
|
|
|
|
|
$this->validate($request, [
|
|
|
|
'limit' => 'nullable|integer|min:1|max:40',
|
|
|
|
'page' => 'nullable|integer|min:1|max:10'
|
|
|
|
]);
|
|
|
|
|
|
|
|
$user = $request->user();
|
|
|
|
$limit = $request->input('limit') ?? 40;
|
|
|
|
|
|
|
|
$blocked = UserFilter::select('filterable_id','filterable_type','filter_type','user_id')
|
|
|
|
->whereUserId($user->profile_id)
|
|
|
|
->whereFilterableType('App\Profile')
|
|
|
|
->whereFilterType('block')
|
|
|
|
->simplePaginate($limit)
|
|
|
|
->pluck('filterable_id');
|
|
|
|
|
|
|
|
$profiles = Profile::findOrFail($blocked);
|
|
|
|
$fractal = new Fractal\Manager();
|
|
|
|
$fractal->setSerializer(new ArraySerializer());
|
|
|
|
$resource = new Fractal\Resource\Collection($profiles, new AccountTransformer());
|
|
|
|
$res = $fractal->createData($resource)->toArray();
|
|
|
|
$url = $request->url();
|
|
|
|
$page = $request->input('page', 1);
|
|
|
|
$next = $page < 40 ? $page + 1 : 40;
|
|
|
|
$prev = $page > 1 ? $page - 1 : 1;
|
|
|
|
$links = '<'.$url.'?page='.$next.'&limit='.$limit.'>; rel="next", <'.$url.'?page='.$prev.'&limit='.$limit.'>; rel="prev"';
|
|
|
|
return response()->json($res, 200, ['Link' => $links]);
|
2021-10-20 10:31:07 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
public function accountBlocksV2(Request $request)
|
|
|
|
{
|
|
|
|
return response()->json(UserFilterService::blocks($request->user()->profile_id), 200, [], JSON_UNESCAPED_SLASHES);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function accountMutesV2(Request $request)
|
|
|
|
{
|
|
|
|
return response()->json(UserFilterService::mutes($request->user()->profile_id), 200, [], JSON_UNESCAPED_SLASHES);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function accountFiltersV2(Request $request)
|
|
|
|
{
|
|
|
|
return response()->json(UserFilterService::filters($request->user()->profile_id), 200, [], JSON_UNESCAPED_SLASHES);
|
2021-01-31 20:45:22 +00:00
|
|
|
}
|
2018-05-26 23:00:07 +00:00
|
|
|
}
|