JWage\APNS\Safari\PackageGenerator

Complexity

Total Complexity

17

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	4
Bugs	1	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	createPushPackageForUser()	0	9	1
B	generatePackage()	0	37	6
A	copyPackageFiles()	0	21	3
A	createPackageManifest()	0	4	1
A	createPackageSignature()	0	6	1
A	createPackageSigner()	0	4	1
A	createPackageManifester()	0	4	1
A	createZipArchive()	0	4	1
A	createPackage()	0	4	1

<?php

namespace JWage\APNS\Safari;

use ErrorException;
use JWage\APNS\Certificate;
use ZipArchive;

class PackageGenerator
{
    /**
     * @var \JWage\APNS\Certificate
     */
    protected $certificate;

    /**
     * @var string
     */
    protected $basePushPackagePath;

    /**
     * @var string
     */
    protected $host;

    /**
     * @var string
     */
    protected $websiteName;

    /**
     * @var string
     */
    protected $websitePushId;

    /**
     * Construct.
     *
     * @param \JWage\APNS\Certificate $certificate
     * @param string $basePushPackagePath
     * @param string $host
     * @param string $websiteName
     * @param string $websitePushId
     */
    public function __construct(
        Certificate $certificate,
        $basePushPackagePath,
        $host,
        $websiteName = '',
        $websitePushId = ''
    ) {
        $this->certificate = $certificate;
        $this->basePushPackagePath = $basePushPackagePath;
        $this->host = $host;
        $this->websiteName = $websiteName;
        $this->websitePushId = $websitePushId;
    }

    /**
     * Create a safari website push notification package for the given User.
     *
     * @param string $userId User id to create package for.
     * @return \JWage\APNS\Safari\Package $package Package instance.
     */
    public function createPushPackageForUser($userId)
    {
        $packageDir = sprintf('/%s/pushPackage%s.%s', sys_get_temp_dir(), time(), $userId);
        $package = $this->createPackage($packageDir, $userId);

        $this->generatePackage($package);

        return $package;
    }

    private function generatePackage(Package $package)
    {
        $packageDir = $package->getPackageDir();
        $zipPath = $package->getZipPath();

        if (!is_dir($packageDir)) {
            mkdir($packageDir);
        }

        $this->copyPackageFiles($package);
        $this->createPackageManifest($package);
        $this->createPackageSignature($package);

        $zip = $this->createZipArchive();

        if (!$zip->open($zipPath, ZipArchive::CREATE)) {
            throw new ErrorException(sprintf('Could not open package "%s"', $zipPath));
        }

        $packageFiles = Package::$packageFiles;
        $packageFiles[] = 'manifest.json';
        $packageFiles[] = 'signature';

        foreach ($packageFiles as $packageFile) {
            $filePath = sprintf('%s/%s', $packageDir, $packageFile);

            if (!file_exists($filePath)) {
                throw new ErrorException(sprintf('File does not exist "%s"', $filePath));
            }

            $zip->addFile($filePath, $packageFile);
        }

        if (false === $zip->close()) {
            throw new ErrorException(sprintf('Could not save package "%s"', $zipPath));
        }
    }

    private function copyPackageFiles(Package $package)
    {
        $packageDir = $package->getPackageDir();

        mkdir($packageDir . '/icon.iconset');

        foreach (Package::$packageFiles as $rawFile) {
            $filePath = sprintf('%s/%s', $packageDir, $rawFile);

            copy(sprintf('%s/%s', $this->basePushPackagePath, $rawFile), $filePath);

            if ($rawFile === 'website.json') {
                $websiteJson = file_get_contents($filePath);
                $websiteJson = str_replace('{{ userId }}', $package->getUserId(), $websiteJson);
                $websiteJson = str_replace('{{ host }}', $this->host, $websiteJson);
                $websiteJson = str_replace('{{ websiteName }}', $this->websiteName, $websiteJson);
                $websiteJson = str_replace('{{ websitePushId }}', $this->websitePushId, $websiteJson);
                file_put_contents($filePath, $websiteJson);
            }
        }
    }

    private function createPackageManifest(Package $package)
    {
        return $this->createPackageManifester()->createManifest($package);
    }

    private function createPackageSignature(Package $package)
    {
        return $this->createPackageSigner()->createPackageSignature(
            $this->certificate, $package
        );
    }

    protected function createPackageSigner()
    {
        return new PackageSigner();
    }

    protected function createPackageManifester()
    {
        return new PackageManifester();
    }

    protected function createZipArchive()
    {
        return new ZipArchive();
    }

    /**
     * @param string $packageDir
     * @param string $userId
     */
    protected function createPackage($packageDir, $userId)
    {
        return new Package($packageDir, $userId);
    }
}