samsoncms / newsletter

src/Application.php

<?php

namespace samsoncms\newsletter;

use samson\activerecord\email_distribution;
use samson\activerecord\email_letter;
use samson\activerecord\email_template;
use samson\core\SamsonLocale;

class Application extends \samsoncms\Application
{
    /** @var string Module identifier */
    protected $id = 'newsletter';

    /** @var string Entity class name */
    protected $entity = '\samson\activerecord\email_distribution';

    /** Application name */
    public $name = 'Newsletter';

    /** Application description */
    public $description = 'Newsletter distribution management';

    /** @var string $icon Icon class */
    public $icon = 'envelope';

    public $hide = false;

    /**
     * Prepare DB for application settings
     * @return mixed
     */
    public function prepare()
    {
        db()->execute(
            "
                CREATE TABLE IF NOT EXISTS `email_distribution` (
                  `distribution_id` int(11) NOT NULL AUTO_INCREMENT,
                  `template_id` int(11) NOT NULL,
                  `status` int(11) DEFAULT '0',
                  `recipient_count` int(11) DEFAULT '0',
                  `bounce_count` int(11) DEFAULT '0',
                  `open_count` int(11) DEFAULT '0',
                  `click_count` int(11) DEFAULT '0',
                  `ts` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
                  `finished` datetime NOT NULL,
                  `active` int(11) NOT NULL DEFAULT '0',
                  PRIMARY KEY (`distribution_id`)
                ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
            "
        );

        db()->execute(
            "
                CREATE TABLE IF NOT EXISTS `email_letter` (
                  `letter_id` int(11) NOT NULL AUTO_INCREMENT,
                  `distribution_id` int(11) NOT NULL,
                  `template_id` int(11) NOT NULL,
                  `recipient` varchar(50) NOT NULL,
                  `status` int(11) DEFAULT '0',
                  `ts` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
                  PRIMARY KEY (`letter_id`)
                ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
            "
        );

        db()->execute(
            "
                CREATE TABLE IF NOT EXISTS `email_template` (
                  `template_id` int(11) NOT NULL AUTO_INCREMENT,
                  `content` text NOT NULL,
                  `locale` varchar(5) NOT NULL DEFAULT 'en',
                  `ts` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
                  PRIMARY KEY (`template_id`)
                ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
            "
        );

        return parent::prepare();
    }

    /**
     * Universal controller action.
     * Entity collection rendering
     */
    public function __template()
    {
        $description = t($this->description, true);
        $name = t($this->description, true);
        $letter = $this->createLetter('HEADER', 'MESSAGE');

        // Prepare view
        $this->title($description)
            ->view('form')
            ->set('name', $name)
            ->set('icon', $this->icon)
            ->set('letter', $letter)
            ->set('description', $description)
        ;
    }

    /**
     * Save number of email opens
     * @param int $distribution_id Distribution identifier
     */
    public function __openaction($distribution_id)
    {
        /** @var email_distribution $distribution */
        $distribution = null;
        if ($this->query->entity('email_distribution')->where('distribution_id', $distribution_id)->first($distribution)) {
            $distribution->open_count ++;

Accessing open_count on the interface samsonframework\orm\RecordInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $distribution->save();
        }
    }

    /**
     * Save number of email clicks
     * @param int $distribution_id Distribution identifier
     * @param string $params
     */
    public function __clickaction($distribution_id, $params = '')
    {
        /** @var email_distribution $distribution */
        $distribution = null;
        if ($this->query->entity('email_distribution')->where('distribution_id', $distribution_id)->first($distribution)) {
            $distribution->click_count ++;

Accessing click_count on the interface samsonframework\orm\RecordInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $distribution->save();

            $params = explode('-', $params);
            $url = 'http://'.$_SERVER['HTTP_HOST'].'/';
            if (sizeof($params)) {
                foreach ($params as $param) {
                    $url .= $param.'/';
                }
            }

            header('Location: '.$url);die;

It is generally recommended to place each PHP statement on a line by itself.

        }
    }

    /**
     * Show template content
     * @param int $id Template identifier
     * @return array
     */
    public function __async_templates($id)

Method name "Application::__async_templates" is not in camel caps format

    {
        /** @var $this->entity $outfit */

The doc-type $this->entity could not be parsed: Unknown type name "$this-" at position 0. (view supported doc-types)

        $template = null;
        $response = array('status' => 0, 'popup' => '');
        if ($this->query->entity('email_template')->where('template_id', $id)->first($template)) {
            $response['popup'] = $this->view('template/popup')->content($template->content)->output();

Accessing content on the interface samsonframework\orm\RecordInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

The method content does not exist on object<samsoncms\newsletter\Application>? Since you implemented __call, maybe consider adding a @method annotation.

            $response['status'] = 1;
        }

        return $response;
    }

    /**
     * Create template content
     * @param string $header Email Header
     * @param string $message Email text
     * @return string
     */
    public function createLetter($header, $message)
    {
        return '<h1>'.$header.'</h1><br><div>'.$message.'</div>';
    }

    /**
     * @param int $preview Flag - send letters or no
     * @return array
     */
    public function __async_make($preview = 0)

Method name "Application::__async_make" is not in camel caps format

    {
        $recipients = explode(',', $_POST['recipients']);

        $letters = array();
        foreach (SamsonLocale::$locales as $locale) {
            if (isset($_POST['header-'.$locale]) && isset($_POST['message-'.$locale])) {
                $letters[$locale] = $this->createLetter($_POST['header-'.$locale], $_POST['message-'.$locale]);
            }
        }

        if (!$preview) {
            $templates = array();

            foreach ($letters as $locale => $letter) {
                $template = new email_template();
                $template->content = $letter;
                $template->locale = $locale;
                $template->save();
                $templates[$locale] = $template;
            }

            $distribution = new email_distribution();
            $distribution->template_id = $templates[SamsonLocale::$defaultLocale]->template_id;
            $distribution->recipient_count = sizeof($recipients);
            $distribution->active = 1;
            $distribution->save();
            // Send emails to all users from POST array
            foreach ($recipients as $recipient) {
                $emailLetter = new email_letter();
                $emailLetter->distribution_id = $distribution->distribution_id;
                $emailLetter->recipient = trim($recipient);
                $emailLetter->template_id = $templates[SamsonLocale::$defaultLocale]->template_id;
                $emailLetter->save();
            }
        }

        return array('status' => 1, 'preview' => $letters[SamsonLocale::$defaultLocale]);
    }

    /**
     * Send manual newsletters
     */
    public function __manual()
    {
        foreach ($this->query->entity('email_letter')->where('status', 0)->exec() as $letter) {

The expression $this->query->entity('email_letter')->where('status', 0)->exec() of type boolean|array<integer,object<samsonframework\orm\RecordInterface>> is not guaranteed to be traversable. How about adding an additional type check?

            $template = $this->query->entity('email_template')->where('template_id', $letter->template_id)->first();
            $message = $template->content;
            $img = '<img width="1" height="1" src="'.url()->build('newsletter/openaction/'.$letter->distribution_id).'">';
            $message .= $img;
            $message = str_replace('clickaction/', 'clickaction/'.$letter->distribution_id.'/', $message);
            $this->sendEmail($message, $letter->recipient);
            $letter->status = 1;
            $letter->save();
        }
    }

    /**
     * @param string $letter Letter html content
     * @param string $recipient email recipient
     * @param string $from Sender email
     * @param string $subject Email subject
     * @param string $user Sender name
     */
    public function sendEmail($letter, $recipient = '', $from = '', $subject = '', $user = '')
    {
        mail_send($recipient, $from, $letter, $subject, $user);
    }
}