/**
* Get the base validator instance for a register request.
*
* @return \Illuminate\Validation\Validator
*/
public function baseValidator()
{
$validator = Spark::interact(CreateUser::class . '@validator', [$this]);
$validator->sometimes('plan', 'required|in:' . Spark::activePlanIdList(), function () {
return Spark::needsCardUpFront();
});
return $validator;
}
/**
* Subscribe the given user to a subscription plan.
*
* @param RegisterRequest $request
* @param \Illuminate\Contracts\Auth\Authenticatable $user
* @return \Illuminate\Contracts\Auth\Authenticatable
*/
protected function subscribe($request, $user)
{
if (!$request->hasPaidPlan()) {
return $user;
}
Spark::interact(Subscribe::class, [$user, $request->plan(), true, $request->all()]);
return $user;
}
/**
* Execute the given interaction.
*
* This performs the common validate and handle flow of some interactions.
*
* @param Request $request
* @param string $interaction
* @param array $parameters
* @return void
*/
public function interaction(Request $request, $interaction, array $parameters)
{
$validator = Spark::interact($interaction . '@validator', $parameters);
if ($validator->fails()) {
$this->throwValidationException($request, $validator);
}
return Spark::interact($interaction, $parameters);
}
/**
* Get the team matching the given ID.
*
* @param Request $request
* @param string $teamId
* @return Response
*/
public function show(Request $request, $teamId)
{
$team = Spark::interact(TeamRepository::class . '@find', [$teamId]);
abort_unless($request->user()->onTeam($team), 404);
if ($request->user()->ownsTeam($team)) {
$team->load('subscriptions');
$team->shouldHaveOwnerVisibility();
}
return $team;
}
/**
* Redeem the given coupon code.
*
* @param Request $request
* @return Response
*/
public function redeem(Request $request)
{
$this->validate($request, ['coupon' => 'required']);
// We will verify that the coupon can actually be redeemed. In some cases even
// valid coupons can not get redeemed by an existing user if this coupon is
// running as a promotion for brand new registrations to the application.
if (!$this->coupons->canBeRedeemed($request->coupon)) {
return response()->json(['coupon' => ['This coupon code is invalid.']], 422);
}
Spark::interact(RedeemCoupon::class, [$request->user(), $request->coupon]);
}
/**
* Disable two-factor authentication for the user.
*
* @param Request $request
* @return Response
*/
public function disable(Request $request)
{
Spark::interact(DisableTwoFactorAuth::class, [$request->user()]);
$request->user()->forceFill(['uses_two_factor_auth' => false])->save();
}
/**
* {@inheritdoc}
*/
public function handle($user, array $data)
{
event(new TeamCreated($team = Spark::interact(TeamRepository::class . '@create', [$user, $data])));
Spark::interact(AddTeamMemberContract::class, [$team, $user, 'owner']);
return $team;
}
/**
* Create the subscription for the team.
*
* @param CreateSubscriptionRequest $request
* @param Team $team
* @return Response
*/
public function store(CreateSubscriptionRequest $request, Team $team)
{
Spark::interact(SubscribeTeam::class, [$team, $request->plan(), $request->all()]);
}
/**
* Get the current team for the user.
*
* @param \Illuminate\Contracts\Auth\Authenticatable $user
* @return \Laravel\Spark\Team|null
*/
protected function currentTeam($user)
{
if (Spark::usesTeams() && $user->currentTeam()) {
return Spark::interact(TeamRepository::class . '@find', [$user->currentTeam()->id]);
}
}
/**
* Accept the given invitations.
*
* @param Request $request
* @param \Laravel\Spark\Invitation $invitation
* @return Response
*/
public function accept(Request $request, Invitation $invitation)
{
abort_unless($request->user()->id == $invitation->user_id, 404);
Spark::interact(AddTeamMember::class, [$invitation->team, $request->user()]);
$invitation->delete();
}
/**
* Create a new invitation.
*
* @param CreateInvitationRequest $request
* @param \Laravel\Spark\Team $team
* @return Response
*/
public function store(CreateInvitationRequest $request, $team)
{
Spark::interact(SendInvitation::class, [$team, $request->email]);
}
/**
* {@inheritdoc}
*/
public function handle($request)
{
return Spark::interact(UserRepository::class . '@create', [$request->all()]);
}
/**
* Create the subscription for the user.
*
* @param CreateSubscriptionRequest $request
* @return Response
*/
public function store(CreateSubscriptionRequest $request)
{
$plan = Spark::plans()->where('id', $request->plan)->first();
Spark::interact(Subscribe::class, [$request->user(), $plan, false, $request->all()]);
}
/**
* Disable two-factor authentication for the given user.
*
* @param \Illuminate\Contracts\Auth\Authenticatable $user
* @return void
*/
protected function disableTwoFactorAuth($user)
{
Spark::interact(DisableTwoFactorAuth::class, [$user]);
$user->forceFill(['uses_two_factor_auth' => false])->save();
}
/**
* Update the payment method for the user.
*
* @param UpdatePaymentMethodRequest $request
* @return Response
*/
public function update(UpdatePaymentMethodRequest $request)
{
Spark::interact(UpdatePaymentMethod::class, [$request->user(), $request->all()]);
}
/**
* Get the users based on the incoming search query.
*
* @param Request $request
* @return Response
*/
public function performBasicSearch(Request $request)
{
$query = str_replace('*', '%', $request->input('query'));
return Spark::interact(UserRepository::class . '@search', [$query, $request->user()]);
}
/**
* Handle a registration request for the application.
*
* @param RegisterRequest $request
* @return Response
*/
public function register(RegisterRequest $request)
{
Auth::login($user = Spark::interact(Register::class, [$request]));
event(new UserRegistered($user));
return response()->json(['redirect' => $this->redirectPath()]);
}
/**
* Verify the given authentication token.
*
* @param Request $request
* @return Response
*/
public function verifyToken(Request $request)
{
$this->validate($request, ['token' => 'required']);
// If there is no authentication ID stored in the session, it means that the user
// hasn't made it through the login screen so we'll just redirect them back to
// the login view. They must have hit the route manually via a specific URL.
if (!$request->session()->has('spark:auth:id')) {
return redirect('login');
}
$user = Spark::user()->findOrFail($request->session()->pull('spark:auth:id'));
// Next, we'll verify the actual token with our two-factor authentication service
// to see if the token is valid. If it is, we can login the user and send them
// to their intended location within the protected part of this application.
if (Spark::interact(Verify::class, [$user, $request->token])) {
Auth::login($user, $request->session()->pull('spark:auth:remember', false));
return redirect()->intended($this->redirectPath());
} else {
return back();
}
}
/**
* Get the current user of the appliation.
*
* @return Response
*/
public function current()
{
return Spark::interact(UserRepository::class . '@current');
}
/**
* Update the payment method for the user.
*
* @param UpdatePaymentMethodRequest $request
* @param Team $team
* @return Response
*/
public function update(UpdatePaymentMethodRequest $request, Team $team)
{
abort_unless($request->user()->ownsTeam($team), 403);
Spark::interact(UpdatePaymentMethod::class, [$team, $request->all()]);
}
