BLUE

Navigation

Breadcrumbs

/ / var / www / multi-event-cfp.bitkit.dk / httpdocs / app / Repositories

Create

Upload

Tip: You can also drag & drop files anywhere on this page to upload.

Edit File Size: 8.53 KB

/var/www/multi-event-cfp.bitkit.dk/httpdocs/app/Repositories/EmailRepository.php

Text Base64

<?php

namespace App\Repositories;

use App\Models\Email;
use App\Models\User;
use Illuminate\Support\Facades\Validator;
use Illuminate\Database\Eloquent\Builder;
use App\Support\Query;
use Illuminate\Support\Facades\DB;
use App\Jobs\SendBulkEmail;
use App\Models\File;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class EmailRepository extends Repository
{
    public function __construct($event = null)
    {
        $this->for($event);
    }

public function model(): ?Email
    {
        return new Email;
    }

public function query($as = null)
    {
        $model = $this->model();
        return $model->newQuery();
    }

public function sendEmail($request, $event)
    {

$data = $request->get('data');
        $data = json_decode($data, true);

$validator = Validator::make($data, [
            'recipients' => ['required'],
            'subject' => ['string', 'max:255'],
            'bcc' => ['nullable'],
            'body' => ['string', 'nullable'],
            'attachment' => ['array', 'nullable'],
            'status' => ['string'],
        ]);

if ($validator->fails()) {
            validationErrorResponse($validator->errors());
        } else {

$id = $data['emailId'] ?? null;
            $email = Email::find($id);

if (!$email) {
                $emailData = $validator->validated();
                $email = new Email([
                    'event_id' => $event->id,
                ]);
                $email = $email->fill($emailData);
                $email->save();
            } else {
                $emailData = $validator->validated();
                $email = $email->fill($emailData);
            }

//handling uploaded files
            $attachmentData = $this->handleEmailFiles($request, $email, $data);
            $email->attachments = $attachmentData;

$email->save();

if ($email->status == "processing") {
                // recipients
                $recipients = array_column($emailData['recipients'], 'email');
                // bcc
                $bccs = array_column($emailData['bcc'], 'email');
                $updatedBcc = [];

foreach ($bccs as $bcc) {
                    $user = User::where('email', $bcc)->first();

if ($user) {
                        if ($user->do_not_send_emails) {
                            $ccEmails = array_filter(array_map('trim', explode(",", $user->cc_emails)));
                            if ($ccEmails) {
                                $updatedBcc = array_merge($updatedBcc, $ccEmails);
                            }
                        } else {
                            $updatedBcc[] = $bcc;
                        }
                    } else {
                        $updatedBcc[] = $bcc;
                    }
                }

// valid bcc
                $validBcc = array_filter(array_map('trim', $updatedBcc), function($email) {
                    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
                });

// send email to user
                dispatch(new SendBulkEmail(array_map('trim', $recipients), $validBcc, $event, $email));
            }

return response([
                'status' => true,
                'message' => "Mail Created Successfully",
                'email' => $email
            ]);
        }
    }

public function handleEmailFiles(Request $request, Email $email, $data)
    {

$attachmentData = $data['attachments'];
        //handling uploaded files
        if ($request->hasFile('attachments')) {
            $files = $request->file('attachments');
            $fileContents = [];
            foreach ($files as $file) {
                $fileObj = $email->saveFile(
                    $file,
                    null,
                    "{$email->id}/files/",
                    "email.file",
                    null,
                    true
                );
                $fileContents[] = $fileObj->getFileObject();
            }

$attachmentData = array_values(array_filter(array_merge($data['attachments'], $fileContents)));
        }
        //handling removed files
        $removedFiles = $data['removed_files'];

if (isset($removedFiles)) {
            $fileIds = $removedFiles;
            foreach ($fileIds as $fileId) {

$this->deleteFile($fileId);
            }
        }

return $attachmentData;
    }

public function delete(Email $email)
    {

if (isset($email->attachments)) {
            foreach ($email->attachments as $attachment) {

$this->deleteFile($attachment['file_id']);
            }
        }

//delete directory
        Storage::deleteDirectory('private/media/emails/' . $email->id);
        $email->delete();
    }

/**
     * @param $fileId
     * @return bool
     */
    public function deleteFile($fileId): bool
    {
        $file = File::find($fileId);
        if (!$file)
            return false;

$delete = Storage::delete($file->filepath . '/' . $file->save_name);
        $file->delete();

return true;
    }

public function selectColumns(): array
    {
        return [
            'emails.id',
            'emails.recipients',
            'emails.bcc',
            'emails.subject',
            'emails.body',
            'emails.status',
            'emails.attachments',
            'emails.send_date',
            'emails.created_at',
        ];
    }

public function scope($arguments, $callback = null)
    {
        //get query builder
        $query = $this->query()
            ->select($this->selectColumns());

//applying different scopes based on the arguments
        $this->applyScope($query, $arguments);

//resolve if there is any callback functions available
        return $this->resolve($query, $arguments, $callback);
    }

public function applyScope(Builder $query, $arguments): Builder
    {
        $this->applyEventScope($query, $arguments);

$this->applyStatus($query, $arguments);

$this->applyOrder($query, $arguments);

$this->applySearch($query, $arguments);

return $query;
    }

public function applyEventScope(Builder $query, $arguments): Builder
    {
        if ($arguments->event) {
            $query->where('emails.event_id', '=', $arguments->event->id);
        }

return $query;
    }

public function applyStatus(Builder $query, $arguments): Builder
    {
        if ($arguments->status) {

$status = strtolower($arguments->status);

$query->where('status', $status);
        }

return $query;
    }

public function applyOrder(Builder $query, Query $arguments): Builder
    {
        $emailColumns = [
            'subject' => 'emails.subject',
            'send_date' => 'emails.send_date',
            'recipients' => 'emails.recipients',
            'created_at' => 'emails.created_at',
        ];

$sorts = json_decode($arguments->sort, true) ?? [];
        foreach ($sorts as $sort => $method) {
            if (array_key_exists($sort, $emailColumns)) {
                $query->orderBy($sort, $method);
            }
        }

return $query;
    }

public function applySearch(Builder $query, $arguments): Builder
    {
        if ($arguments->search) {
            $emailColumns = [
                'subject' => 'emails.subject',
                'send_date' => 'emails.send_date',
                'recipients' => 'emails.recipients',
                'created_at' => 'emails.created_at',
            ];
            $search = strtolower($arguments->search);
            $query->where(function ($query) use ($search, $emailColumns) {
                foreach ($emailColumns as $emailColumn) {
                    $query->orWhere(DB::raw("lower($emailColumn)"), 'like', "%{$search}%");
                }
            });
        }

return $query;
    }

public function listing($request, $paginate)
    {
        //building arguments
        $arguments = $this->arguments($request);

//building query
        $query = $this->scope($arguments);

return ($paginate && $arguments->paging != 'All') ? $query->paginate($arguments->paging, ['*'], 'page', $arguments->page) : $query->get();
    }
}

Exit & Reset Text mode: syntax highlighting auto-detects file type.

Directory Contents

Dirs: 0 × Files: 17

Sort:

Enable drag-to-move

Name	Size	Perms	Modified	Actions
AbstractsRepository.php	75.27 KB	lrw-rw-r--	2026-04-30 09:24:04	Edit Download recursive recursive
AmendSpeakerTermsRepository.php	1.21 KB	lrw-rw-r--	2025-04-21 06:11:52	Edit Download recursive recursive
ApiRepository.php	65 B	lrw-r--r--	2024-02-09 12:37:30	Edit Download recursive recursive
AuthRepository.php	8.53 KB	lrw-rw-r--	2025-03-03 05:39:26	Edit Download recursive recursive
EmailLogRepository.php	4.14 KB	lrw-rw-r--	2025-10-28 05:24:52	Edit Download recursive recursive
EmailRepository.php	8.53 KB	lrw-rw-r--	2025-10-28 05:24:35	Edit Download recursive recursive
EventRepository.php	37.58 KB	lrw-rw-r--	2026-04-07 05:00:51	Edit Download recursive recursive
PresentationCommentRepository.php	8.71 KB	lrw-r--r--	2024-02-09 12:37:30	Edit Download recursive recursive
PresentationRepository.php	59.48 KB	lrwxrwxr-x	2026-04-30 09:24:03	Edit Download recursive recursive
Repository.php	4.78 KB	lrw-r--r--	2024-02-09 12:37:30	Edit Download recursive recursive
ScheduleEmailRepository.php	10.79 KB	lrw-rw-r--	2025-04-21 06:11:52	Edit Download recursive recursive
ScoreRepository.php	11.37 KB	lrw-rw-r--	2024-07-24 04:42:48	Edit Download recursive recursive
SessionRepository.php	72.51 KB	lrw-rw-r--	2026-04-22 04:31:21	Edit Download recursive recursive
SlotRepository.php	11.43 KB	lrw-rw-r--	2024-09-20 05:02:14	Edit Download recursive recursive
SpeakerNotesRepository.php	6.57 KB	lrw-rw-r--	2026-03-31 07:16:20	Edit Download recursive recursive
SystemEmailRepository.php	4.26 KB	lrw-r--r--	2024-02-09 12:37:30	Edit Download recursive recursive
UserRepository.php	128.96 KB	lrw-rw-r--	2026-05-07 09:06:13	Edit Download recursive recursive