merge 1

Signed-off-by: miguel456 <me@nogueira.codes>

app/Services/AbsenceService.php

@@ -0,0 +1,183 @@
+<?php
+
+namespace App\Services;
+
+use App\Absence;
+use App\Exceptions\AbsenceNotActionableException;
+use App\Notifications\AbsenceRequestApproved;
+use App\Notifications\AbsenceRequestCancelled;
+use App\Notifications\AbsenceRequestDeclined;
+use App\Notifications\AbsenceRequestEnded;
+use App\Notifications\NewAbsenceRequest;
+use App\User;
+use Carbon\Carbon;
+use Illuminate\Contracts\Auth\Authenticatable;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Log;
+use Spatie\Permission\Models\Role;
+
+
+class AbsenceService
+{
+
+    /**
+     * Determines whether someone already has an active leave of absence request
+     *
+     * @param User $user The user to check
+     * @return bool Their status
+     */
+    public function hasActiveRequest(Authenticatable $user): bool {
+
+        $absences = Absence::where('requesterID', $user->id)->get();
+
+        foreach ($absences as $absence) {
+
+            // Or we could adjust the query (using a model scope) to only return valid absences;
+            // If there are any, refuse to store more, but this approach also works
+            // A model scope that only returns cancelled, declined and ended absences could also be implemented for future use
+            if (in_array($absence->getRawOriginal('status'), ['PENDING', 'APPROVED']))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function createAbsence(Authenticatable $requester, Request $request)
+    {
+
+        $absence = Absence::create([
+            'requesterID' => $requester->id,
+            'start' => $request->start_date,
+            'predicted_end' => $request->predicted_end,
+            'available_assist' => $request->available_assist == "on",
+            'reason' => $request->reason,
+            'status' => 'PENDING',
+        ]);
+
+        foreach(User::role('admin')->get() as $admin) {
+            $admin->notify(new NewAbsenceRequest($absence));
+        }
+
+        Log::info('Processing new leave of absence request.', [
+            'requesting_user' => $requester->email,
+            'absenceid' => $absence->id,
+            'reason' => $request->reason
+        ]);
+
+        return $absence;
+    }
+
+
+    /**
+     * Sets an absence as Approved.
+     *
+     * @param Absence $absence The absence to approve.
+     * @return Absence The approved absence.
+     * @throws AbsenceNotActionableException
+     */
+    public function approveAbsence(Absence $absence)
+    {
+        Log::info('An absence request has just been approved.', [
+            'absenceid' => $absence->id,
+            'reviewing_admim' => Auth::user()->email,
+            'new_status' => 'APPROVED'
+        ]);
+
+        return $absence
+            ->setApproved()
+            ->requester->notify(new AbsenceRequestApproved($absence));
+    }
+
+
+    /**
+     * Sets an absence as Declined.
+     *
+     * @param Absence $absence The absence to decline.
+     * @return Absence The declined absence.
+     * @throws AbsenceNotActionableException
+     */
+    public function declineAbsence(Absence $absence)
+    {
+        Log::warning('An absence request has just been declined.', [
+            'absenceid' => $absence->id,
+            'reviewing_admim' => Auth::user()->email,
+            'new_status' => 'DECLINED'
+        ]);
+
+        return $absence
+            ->setDeclined()
+            ->requester->notify(new AbsenceRequestDeclined($absence));
+    }
+
+
+    /**
+     * Sets an absence as Cancelled.
+     *
+     * @param Absence $absence The absence to cancel.
+     * @return Absence The cancelled absence.
+     * @throws AbsenceNotActionableException
+     */
+    public function cancelAbsence(Absence $absence)
+    {
+        Log::warning('An absence request has just been cancelled (only cancellable by requester).', [
+            'absenceid' => $absence->id,
+            'new_status' => 'CANCELLED'
+        ]);
+
+        return $absence
+            ->setCancelled()
+            ->requester->notify(new AbsenceRequestCancelled($absence));
+    }
+
+    /**
+     * Sets an absence as Ended.
+     *
+     * @param Absence $absence
+     * @return bool
+     */
+    public function endAbsence(Absence $absence)
+    {
+        Log::info('An absence request has just expired.', [
+            'absenceid' => $absence->id,
+            'new_status' => 'ENDED'
+        ]);
+
+        return $absence
+            ->setEnded()
+            ->requester->notify(new AbsenceRequestEnded($absence));
+    }
+
+    /**
+     * Removes an absence
+     *
+     * @param Absence $absence The absence to remove.
+     * @return bool Whether the absence was removed.
+     */
+    public function removeAbsence(Absence $absence): bool
+    {
+        Log::alert('An absence request has just been removed.', [
+            'absence_details' => $absence,
+            'reviewing_admim' => Auth::user()->email,
+        ]);
+
+        return $absence->delete();
+    }
+
+
+    public function endExpired()
+    {
+        foreach (Absence::all() as $absence)
+        {
+            if (!Carbon::parse($absence->predicted_end)->isFuture()) {
+                $this->endAbsence($absence);
+            }
+        }
+    }
+
+
+
+}
+

app/Services/AccountSuspensionService.php

@@ -16,18 +16,14 @@ class AccountSuspensionService
 
     /**
      * Suspends a user account, with given $reason.
+     * Permanent if no duration given.
      *
-     * This method will take the target user and add a suspension to the database,
-     * effectively banning the user from the app. Suspensions may be temporary or permanent.
-     * Suspensions also block registration attempts.
-     *
-     * @param string $reason Suspension reason.
-     * @param string $duration Duration. This is a timestamp.
      * @param User $target Who to suspend.
-     * @param string $type Permanent or temporary?
+     * @param string $reason Suspension reason.
+     * @param int|null $duration Duration in days
      * @return Ban The ban itself
      */
-    public function suspend($reason, $duration, User $target, $type = "on"): Ban {
+    public function suspend(User $target, string $reason, int $duration = null): Ban {
 
         Log::alert("An user account has just been suspended.", [
             'taget_email' => $target->email,
@@ -35,19 +31,17 @@ class AccountSuspensionService
             'reason' => $reason
         ]);
 
-        if ($type == "on") {
+        if ($duration > 0) {
             $expiryDate = now()->addDays($duration);
         }
 
-        $ban = Ban::create([
+        return Ban::create([
             'userID' => $target->id,
             'reason' => $reason,
-            'bannedUntil' => ($type == "on") ? $expiryDate->format('Y-m-d H:i:s') : null,
+            'bannedUntil' => ($duration > 0) ? $expiryDate->format('Y-m-d H:i:s') : null,
             'authorUserID' => Auth::user()->id,
-            'isPermanent' => ($type == "off") ? true : false
+            'isPermanent' => ($duration == 0) ? true : false
         ]);
-
-        return $ban;
     }
 
     /**
@@ -64,6 +58,16 @@ class AccountSuspensionService
         $user->bans->delete();
     }
 
+    /**
+     * Checks whether a user is suspended
+     *
+     * @param User $user The user to check
+     * @return bool Whether the mentioned user is suspended
+     */
+    public function isSuspended(User $user): bool {
+        return !is_null($user->bans);
+    }
+
 
 
 
@@ -107,19 +111,6 @@ class AccountSuspensionService
         return $user->save();
     }
 
-
-
-    /**
-     * Checks whether a user is suspended
-     *
-     * @param User $user The user to check
-     * @return bool Whether the mentioned user is suspended
-     */
-    public function isSuspended(User $user): bool {
-        return !is_null($user->bans);
-    }
-
-
     /**
      * Checks whether an account is locked
      *
@@ -131,21 +122,21 @@ class AccountSuspensionService
     }
 
     /**
-     * Takes a suspension directly and makes it permanent.
+     * Retrieves the reason for the user's suspension.
      *
-     * @param Ban $ban The suspension to make permanent
+     * @param User $user The user account to check
+     * @return string|bool Reason for the suspension, false if not suspended
      */
-    public function makePermanent(Ban $ban): void {
+    public function getSuspensionReason(User $user): string|bool {
+        return ($this->isSuspended($user)) ? $user->bans->reason : false;
+    }
 
-        Log::alert('A suspension has just been made permanent.', [
-            'target_email' => $ban->user->email
-        ]);
-
-        $ban->bannedUntil = null;
-        $ban->isPermanent = true;
-
-        $ban->save();
+    public function getSuspensionDuration(User $user): string|null {
+        if ($this->isSuspended($user) && !is_null($user->bans->bannedUntil)) {
+            return $user->bans->bannedUntil->diffForHumans();
+        }
 
+        return null;
     }
 
     /**

app/Services/ApplicationService.php

@@ -3,7 +3,11 @@
 
 namespace App\Services;
 
+use App\Exceptions\DiscordAccountRequiredException;
+use App\Exceptions\IncompatibleAgeException;
+use App\Exceptions\InvalidAgeException;
 use App\Notifications\ApplicationConfirmed;
+use Carbon\Carbon;
 use ContextAwareValidator;
 use App\Application;
 use App\Events\ApplicationDeniedEvent;
@@ -22,12 +26,27 @@ use Illuminate\Support\Facades\Log;
 
 class ApplicationService
 {
+    /**
+     * @throws DiscordAccountRequiredException
+     * @throws IncompatibleAgeException
+     * @throws InvalidAgeException
+     */
     public function renderForm($vacancySlug)
     {
         $vacancyWithForm = Vacancy::with('forms')->where('vacancySlug', $vacancySlug)->get();
-
         $firstVacancy = $vacancyWithForm->first();
 
+        if (is_null(Auth::user()->dob)) {
+            throw new InvalidAgeException("User must have added their age to apply for this vacancy.");
+        } elseif(Carbon::parse(Auth::user()->dob)->age < $firstVacancy->requiredAge) {
+            throw new IncompatibleAgeException("Sorry, you must be {$firstVacancy->requiredAge} or older to apply to {$firstVacancy->vacancyName}.");
+        }
+
+
+        if ($firstVacancy->requiresDiscord && !Auth::user()->hasDiscordConnection()) {
+            throw new DiscordAccountRequiredException('A discord account is required beyond this point.');
+        }
+
         if (!$vacancyWithForm->isEmpty() && $firstVacancy->vacancyCount !== 0 && $firstVacancy->vacancyStatus == 'OPEN') {
             return view('dashboard.application-rendering.apply')
                 ->with([
@@ -36,7 +55,7 @@ class ApplicationService
                 ]);
         } else {
 
-            throw new ApplicationNotFoundException('The application you\'re looking for could not be found or it is currently unavailable.', 404);
+            throw new ApplicationNotFoundException(__('The application you\'re looking for could not be found or it is currently unavailable.'), 404);
 
         }
     }
@@ -94,11 +113,12 @@ class ApplicationService
                 'applicant' => $applicant->name
             ]);
 
-            foreach (User::all() as $user) {
-                if ($user->hasRole('admin')) {
-                    $user->notify((new NewApplicant($application, $vacancy->first())));
-                }
-            }
+            User::whereHas('roles', function ($q) {
+                $q->where('name', 'admin');
+            })->get()->each(function ($user, $key) use ($application, $vacancy) {
+                $user->notify((new NewApplicant($application, $vacancy->first())));
+            });
+
             $application->user->notify(new ApplicationConfirmed($application));
 
             return true;

app/Services/DiscordService.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Services;
+
+use App\User;
+use Illuminate\Http\Client\RequestException;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Http;
+
+class DiscordService
+{
+
+    /**
+     * Sends a token revocation request to Discord to invalidate a specific $user's tokens.
+     * Please ensure you have the user set a password for their account after this, or request new tokens.
+     *
+     * @see https://www.rfc-editor.org/rfc/rfc7009
+     * @param User $user
+     * @return bool
+     * @throws RequestException
+     */
+    public function revokeAccountTokens(User $user): bool
+    {
+        $req = Http::asForm()->post(config('services.discord.base_url') . '/oauth2/token/revoke', [
+            'client_id' => config('services.discord.client_id'),
+            'client_secret' => config('services.discord.client_secret'),
+            'token' => $user->discord_token,
+        ])->throw();
+
+
+
+        $user->discord_token = null;
+        $user->discord_user_id = null;
+        $user->discord_refresh_token = null;
+        $user->discord_pfp = null;
+        $user->save();
+
+        return $req->ok();
+    }
+
+
+}

app/Services/FormManagementService.php

@@ -39,7 +39,7 @@ class FormManagementService
 
         $deletable = true;
 
-        if (! is_null($form) && ! is_null($form->vacancies) && $form->vacancies->count() !== 0 || ! is_null($form->responses)) {
+        if (! is_null($form->vacancies) && $form->vacancies->count() !== 0 || ! is_null($form->responses)) {
             $deletable = false;
         }
 

app/Services/ProfileService.php

@@ -4,15 +4,56 @@
 namespace App\Services;
 
 
+use App\Exceptions\ProfileAlreadyExistsException;
+use App\Exceptions\ProfileCreationFailedException;
 use App\Exceptions\ProfileNotFoundException;
+use App\Profile;
 use App\User;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Log;
 
 class ProfileService
 {
 
     /**
+     * Creates a new profile for the specified $targetUser.
+     *
+     * @param User $targetUser The user to create the profile for.
+     * @return bool
+     * @throws ProfileAlreadyExistsException
+     * @throws ProfileCreationFailedException
+     */
+    public function createProfile(User $targetUser): Profile {
+
+        if (is_null($targetUser->profile)) {
+
+            $profile = Profile::create([
+
+                'profileShortBio' => 'Write a one-liner about you here!',
+                'profileAboutMe' => 'Tell us a bit about you.',
+                'socialLinks' => '{}',
+                'userID' => $targetUser->id,
+
+            ]);
+
+            if (is_null($profile)) {
+                throw new ProfileCreationFailedException(__('Could not create profile! Please try again later.'));
+            }
+
+            Log::info('Created profile for new user', [
+                'userid' => $targetUser->id
+            ]);
+
+            return $profile;
+        }
+
+        throw new ProfileAlreadyExistsException(__('Profile already exists!'));
+    }
+
+    /**
+     * Updates the user's profile.
+     *
      * @throws ProfileNotFoundException
      */
     public function updateProfile($userID, Request $request) {
@@ -47,4 +88,26 @@ class ProfileService
         throw new ProfileNotFoundException("This profile does not exist.");
     }
 
+    /**
+     * Delete specified user's profile
+     *
+     * @param User $targetUser
+     * @return bool
+     * @throws ProfileNotFoundException
+     */
+    public function deleteProfile(User $targetUser): bool
+    {
+
+        if (!is_null($targetUser->profile)) {
+
+            Log::alert('Deleted user profile', [
+                'userid' => $targetUser->id
+            ]);
+
+            return $targetUser->profile->delete();
+        }
+
+        throw new ProfileNotFoundException(__('Attempting to delete non-existant profile!'));
+    }
+
 }