Firesphere\PartialUserforms\Jobs\PartialSubmissionJob

Complexity

Total Complexity

40

Size/Duplication

Total Lines	293
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

100%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	setup()	0	6	1
A	validateEmails()	0	19	5
A	getTitle()	0	4	1
A	process()	0	31	4
A	getParents()	0	25	5
A	buildCSV()	0	22	2
A	processSubmissions()	0	27	5
A	sendEmail()	0	17	4
A	afterComplete()	0	15	4
A	cleanupSubmissions()	0	14	3
A	createNewJob()	0	8	1
A	getMessages()	0	4	1
A	getAddresses()	0	4	1
A	addAddress()	0	6	2
A	getConfig()	0	4	1

<?php

namespace Firesphere\PartialUserforms\Jobs;

use Exception;
use Firesphere\PartialUserforms\Models\PartialFieldSubmission;
use Firesphere\PartialUserforms\Models\PartialFormSubmission;
use Firesphere\PartialUserforms\Services\DateService;
use SilverStripe\Control\Director;
use SilverStripe\Control\Email\Email;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\FieldType\DBDatetime;
use SilverStripe\ORM\ValidationException;
use SilverStripe\SiteConfig\SiteConfig;
use SilverStripe\UserForms\Model\UserDefinedForm;
use Symbiote\QueuedJobs\Services\AbstractQueuedJob;
use Symbiote\QueuedJobs\Services\QueuedJobService;

/**
 * Class PartialSubmissionJob
 * @package Firesphere\PartialUserforms\Jobs
 */
class PartialSubmissionJob extends AbstractQueuedJob
{
    use Extensible;

    /**
     * The generated CSV files
     * @var array
     */
    protected $files = [];

    /**
     * @var SiteConfig
     */
    protected $config;

    /**
     * @var array
     */
    protected $addresses;


    /**
     * Prepare the data
     */
    public function setup()
    {
        parent::setup();
        $this->config = SiteConfig::current_site_config();
        $this->validateEmails();
    }

    /**
     * Only add valid email addresses
     */
    protected function validateEmails()
    {
        $email = $this->config->SendMailTo;
        $result = Email::is_valid_address($email);
        if ($result) {
            $this->addresses[] = $email;
        }
        if (strpos($email, ',') !== false) {
            $emails = explode(',', $email);
            foreach ($emails as $address) {
                $result = Email::is_valid_address(trim($address));
                if ($result) {
                    $this->addresses[] = trim($address);
                } else {
                    $this->addMessage($address . _t(__CLASS__ . '.invalidMail', ' is not a valid email address'));
                }
            }
        }
    }

    /**
     * @return string
     */
    public function getTitle()
    {
        return _t(__CLASS__ . '.Title', 'Export partial submissions to Email');
    }

    /**
     * Do some processing yourself!
     */
    public function process()
    {
        if (!$this->config->SendDailyEmail) {
            $this->addMessage(_t(__CLASS__ . '.NotActive', 'Daily exports are not enabled'));
            $this->isComplete = true;

            return;
        }
        if (!count($this->addresses)) {
            $this->addMessage(_t(__CLASS__ . '.EmailError', 'Can not process without valid email'));
            $this->isComplete = true;

            return;
        }

        $userDefinedForms = $this->getParents();

        /** @var UserDefinedForm $form */
        foreach ($userDefinedForms as $form) {
            $fileName = _t(__CLASS__ . '.Export', 'Export of ') .
                $form->Title . ' - ' .
                DBDatetime::now()->Format(DBDatetime::ISO_DATETIME);
            $file = '/tmp/' . $fileName . '.csv';
            $this->files[] = $file;
            $this->buildCSV($file, $form);
        }

        $this->sendEmail();

        $this->isComplete = true;
    }

    /**
     * @return ArrayList
     */
    protected function getParents()
    {
        /** @var DataList|PartialFormSubmission[] $exportForms */
        $allSubmissions = PartialFormSubmission::get()->filter(['IsSend' => false]);
        /** @var ArrayList|UserDefinedForm[] $parents */
        $userDefinedForms = ArrayList::create();

        /** @var PartialFormSubmission $submission */
        /** @noinspection ForeachSourceInspection */
        foreach ($allSubmissions as $submission) {
            // Due to having to support Elemental ElementForm, we need to manually get the parent
            // It's a bit a pickle, but it works
            $parentClass = $submission->ParentClass;
            $parent = $parentClass::get()->byID($submission->UserDefinedFormID);
            if ($parent &&
                $parent->ExportPartialSubmissions &&
                !$userDefinedForms->find('ID', $parent->ID)
            ) {
                $userDefinedForms->push($parent);
            }
            $submission->destroy();
        }

        return $userDefinedForms;
    }

    /**
     * @param string $file
     * @param UserDefinedForm $form
     * @throws ValidationException
     */
    protected function buildCSV($file, $form)
    {
        $excludeFields = [
            'Name:PartialMatch' => 'EditableFormStep'
        ];
        $filter = [
            'UserDefinedFormID' => $form->ID
        ];
        $resource = fopen($file, 'w+');
        /** @var DataList|PartialFormSubmission[] $submissions */
        $submissions = PartialFormSubmission::get()->filter($filter);
        $headerFields = $form
            ->Fields()
            ->exclude($excludeFields)
            ->column('Title');
        fputcsv($resource, $headerFields);

        if ($submissions->count()) {
            $this->processSubmissions($form, $submissions, $resource);
        }
        fclose($resource);
    }

    /**
     * @param UserDefinedForm $form
     * @param DataList|PartialFormSubmission[] $submissions
     * @param resource $resource
     * @throws ValidationException
     */
    protected function processSubmissions($form, $submissions, $resource)
    {
        $editableFields = $form
            ->Fields()
            ->exclude(['Name:PartialMatch' => 'EditableFormStep'])
            ->map('Name', 'Title')
            ->toArray();
        $i = 0;
        $submitted = [];
        foreach ($submissions as $submission) {
            $values = $submission->PartialFields()->map('Name', 'Value')->toArray();
            foreach ($editableFields as $field => $title) {
                if (isset($values[$field])) {
                    $submitted[$i][] = $values[$field];
                } else {
                    $submitted[$i][] = '';
                }
            }
            $i++;
            $submission->IsSend = true;
            $submission->write();
        }
        $this->extend('updateCSVRecords', $submitted, $editableFields);
        foreach ($submitted as $submitItem) {
            fputcsv($resource, $submitItem);
        }
    }

    /**
     * Send out the email(s)
     */
    protected function sendEmail()
    {
        /** @var Email $mail */
        $mail = Email::create();
        $mail->setSubject('Partial form submissions of ' . DBDatetime::now()->Format(DBDatetime::ISO_DATETIME));
        foreach ($this->files as $file) {
            $mail->addAttachment($file);
        }
        $from = $this->config->SendMailFrom ?: 'site@' . Director::host();

        $mail->setFrom($from);
        foreach ($this->addresses as $address) {
            $mail->setTo($address);
            $mail->setBody('Please see attached CSV files');
            $mail->send();
        }
    }

    /**
     * @throws Exception
     */
    public function afterComplete()
    {
        // Remove the files created in the process
        foreach ($this->files as $file) {
            unlink($file);
        }

        parent::afterComplete();
        if ($this->config->CleanupAfterSend) {
            $this->cleanupSubmissions();
        }
        if ($this->config->SendDailyEmail) {
            $this->createNewJob();
        }
    }

    /**
     * Remove submissions that have been sent out
     */
    protected function cleanupSubmissions()
    {
        /** @var DataList|PartialFormSubmission[] $forms */
        $forms = PartialFormSubmission::get()->filter(['IsSend' => true]);
        foreach ($forms as $form) {
            /** @var DataList|PartialFieldSubmission[] $fields */
            if ($form->PartialFields()->column('ID')) {
                $fields = PartialFieldSubmission::get()->filter(['ID' => $form->PartialFields()->column('ID')]);
                $fields->removeAll();
            }
            $form->delete();
            $form->destroy();
        }
    }

    /**
     * Create a new queued job for tomorrow
     * @throws Exception
     */
    protected function createNewJob()
    {
        $job = new self();
        /** @var QueuedJobService $queuedJob */
        $queuedJob = Injector::inst()->get(QueuedJobService::class);
        $tomorrow = DateService::getTomorrow();
        $queuedJob->queueJob($job, $tomorrow->Format(DBDatetime::ISO_DATETIME));
    }

    /**
     * @return array
     */
    public function getMessages()
    {
        return $this->messages;
    }

    /**
     * @return array
     */
    public function getAddresses()
    {
        return $this->addresses;
    }

    /**
     * @param string $address
     */
    public function addAddress($address)
    {
        if (Email::is_valid_address($address)) {
            $this->addresses[] = $address;
        }
    }

    /**
     * @return SiteConfig
     */
    public function getConfig()
    {
        return $this->config;
    }
}