Repository::initContentDb() - Code Metrics - Inspection of "Minor tweak in composer file" - jenskooij/cloudcontrol - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 9c6499...c22bc5 )

by Jens

created 2017-08-23 14:50 UTC

Repository::initContentDb() A

↳ Parent: Repository

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * User: Jens
 * Date: 30-1-2017
 * Time: 20:15
 */

namespace CloudControl\Cms\storage;
use CloudControl\Cms\storage\storage\DocumentStorage;

/**
 * Class Repository
 * @package CloudControl\Cms\storage
 * @property array sitemap
 * @property array applicationComponents
 * @property array documentTypes
 * @property array bricks
 * @property array imageSet
 * @property array images
 * @property array files
 * @property array users
 * @property array valuelists
 * @property array redirects
 */
class Repository
{
    protected $storagePath;

    protected $fileBasedSubsets = array('sitemap', 'applicationComponents', 'documentTypes', 'bricks', 'imageSet', 'images', 'files', 'users', 'valuelists', 'redirects');

    protected $sitemap;
    protected $sitemapChanges = false;

    protected $applicationComponents;
    protected $applicationComponentsChanges = false;

    protected $documentTypes;
    protected $documentTypesChanges = false;

    protected $bricks;
    protected $bricksChanges = false;

    protected $imageSet;
    protected $imageSetChanges = false;

    protected $images;
    protected $imagesChanges = false;

    protected $files;
    protected $filesChanges = false;

    protected $users;
    protected $usersChanges = false;

    protected $valuelists;
    protected $valuelistsChanges = false;

    protected $redirects;
    protected $redirectsChanges = false;

    protected $contentDbHandle;


    /**
     * Repository constructor.
     * @param $storagePath
     * @throws \Exception
     */
    public function __construct($storagePath)
    {
        $storagePath = realpath($storagePath);
        if (is_dir($storagePath) && $storagePath !== false) {
            $this->storagePath = $storagePath;
        } else {
            throw new \Exception('Repository not yet initialized.');
        }
    }

    /**
     * Creates the folder in which to create all storage related files
     *
     * @param $storagePath
     * @return bool
     */
    public static function create($storagePath)
    {
        return mkdir($storagePath);
    }

    /**
     * Initiates default storage
     * @param $baseStorageDefaultPath
     * @param $baseStorageSqlPath
     */
    public function init($baseStorageDefaultPath, $baseStorageSqlPath)
    {
        // TODO Make sure storage isnt overwritten when its already initialized
        $storageDefaultPath = realpath($baseStorageDefaultPath);
        $contentSqlPath = realpath($baseStorageSqlPath);

        $this->initConfigStorage($storageDefaultPath);
        $this->initContentDb($contentSqlPath);

        $this->save();
    }

    /**
     * Load filebased subset and return it's contents
     *
     * @param $name
     * @return mixed|string
     * @throws \Exception
     */
    public function __get($name)
    {
        if (isset($this->$name)) {
            if (in_array($name, $this->fileBasedSubsets)) {

                return $this->$name;
            } else {
                throw new \Exception('Trying to get undefined property from Repository: ' . $name);
            }
        } else {

            if (in_array($name, $this->fileBasedSubsets)) {
                return $this->loadSubset($name);
            } else {
                throw new \Exception('Trying to get undefined property from Repository: ' . $name);
            }
        }
    }

    /**
     * Set filebased subset contents
     * @param $name
     * @param $value
     * @throws \Exception
     */
    public function __set($name, $value)
    {
        if (in_array($name, $this->fileBasedSubsets)) {
            $this->$name = $value;
            $changes = $name . 'Changes';
            $this->$changes = true;
        } else {
            throw new \Exception('Trying to persist unknown subset in repository: ' . $name . ' <br /><pre>' . print_r($value, true) . '</pre>');
        }
    }

    /**
     * Persist all subsets
     */
    public function save()
    {
        $host = $this;
        array_map(function ($value) use ($host) {
            $host->saveSubset($value);
		}, $this->fileBasedSubsets);
    }

    /**
     * Persist subset to disk
     * @param $subset
     */
    public function saveSubset($subset)
    {
		$changes = $subset . 'Changes';
		if ($this->$changes === true) {
            if (!defined('JSON_PRETTY_PRINT')) {
                $json = json_encode($this->$subset);
            } else {
                $json = json_encode($this->$subset, JSON_PRETTY_PRINT);
            }
			$subsetStoragePath = $this->storagePath . DIRECTORY_SEPARATOR . $subset . '.json';
			file_put_contents($subsetStoragePath, $json);

			$this->$changes = false;
		}
    }

    /**
     * Load subset from disk
     * @param $subset
     * @return mixed|string
     */
    protected function loadSubset($subset)
    {
        $subsetStoragePath = $this->storagePath . DIRECTORY_SEPARATOR . $subset . '.json';
        $json = file_get_contents($subsetStoragePath);
        $json = json_decode($json);
        $this->$subset = $json;
        return $json;
    }

    /**
     * @param $contentSqlPath
     */
    protected function initContentDb($contentSqlPath)
    {
        $db = $this->getContentDbHandle();
        $sql = file_get_contents($contentSqlPath);
        $db->exec($sql);
    }

    /**
     * @param $storageDefaultPath
     */
    protected function initConfigStorage($storageDefaultPath)
    {
        $json = file_get_contents($storageDefaultPath);
        $json = json_decode($json);
        $this->sitemap = $json->sitemap;
        $this->sitemapChanges = true;
        $this->applicationComponents = $json->applicationComponents;
        $this->applicationComponentsChanges = true;
        $this->documentTypes = $json->documentTypes;
        $this->documentTypesChanges = true;
        $this->bricks = $json->bricks;
        $this->bricksChanges = true;
        $this->imageSet = $json->imageSet;
        $this->imageSetChanges = true;
        $this->images = $json->images;
        $this->imagesChanges = true;
        $this->files = $json->files;
        $this->filesChanges = true;
        $this->users = $json->users;
        $this->usersChanges = true;
        $this->valuelists = $json->valuelists;
        $this->valuelistsChanges = true;
        $this->redirects = $json->redirects;
        $this->redirectsChanges = true;
    }

    /**
     * @return \PDO
     */
    public function getContentDbHandle()
    {
        if ($this->contentDbHandle === null) {
            $this->contentDbHandle = new \PDO('sqlite:' . $this->storagePath . DIRECTORY_SEPARATOR . 'content.db');
        }
        return $this->contentDbHandle;
    }

	/**
	 * Get all documents
	 *
	 * @param string $state
	 *
	 * @return array
	 * @throws \Exception
	 */
    public function getDocuments($state = 'published')
    {
		if (!in_array($state, Document::$DOCUMENT_STATES)) {
			throw new \Exception('Unsupported document state: ' . $state);
		}
        return $this->getDocumentsByPath('/', $state);
    }

	public function getDocumentsWithState($folderPath = '/')
	{
		$db = $this->getContentDbHandle();
		$folderPathWithWildcard = $folderPath . '%';

		$ifRootIndex = 1;
		if ($folderPath == '/') {
			$ifRootIndex = 0;
		}

		$sql = '
            SELECT documents_unpublished.*,
            	   IFNULL(documents_published.state,"unpublished") as state,
            	   IFNULL(documents_published.publicationDate,NULL) as publicationDate,
            	   (documents_published.lastModificationDate != documents_unpublished.lastModificationDate) as unpublishedChanges 
              FROM documents_unpublished
		 LEFT JOIN documents_published
         		ON documents_published.path = documents_unpublished.path
             WHERE documents_unpublished.`path` LIKE ' . $db->quote($folderPathWithWildcard) . '
               AND substr(documents_unpublished.`path`, ' . (strlen($folderPath) + $ifRootIndex + 1) . ') NOT LIKE "%/%"
               AND length(documents_unpublished.`path`) > ' . (strlen($folderPath) + $ifRootIndex) . '
               AND documents_unpublished.path != ' . $db->quote($folderPath) . '
          ORDER BY documents_unpublished.`type` DESC, documents_unpublished.`path` ASC
        ';
		$stmt = $this->getDbStatement($sql);



		$documents = $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
		foreach ($documents as $key => $document) {
			$documents = $this->setAssetsToDocumentFolders($document, $db, $documents, $key);
		}
		//dump($documents);
		return $documents;
	}

	/**
	 * Get all documents and folders in a certain path
	 *
	 * @param        $folderPath
	 * @param string $state
	 *
	 * @return array
	 * @throws \Exception
	 */
    public function getDocumentsByPath($folderPath, $state = 'published')
    {
    	if (!in_array($state, Document::$DOCUMENT_STATES)) {
    		throw new \Exception('Unsupported document state: ' . $state);
		}
        $db = $this->getContentDbHandle();
        $folderPathWithWildcard = $folderPath . '%';

        $sql = 'SELECT *
              FROM documents_' . $state . '
             WHERE `path` LIKE ' . $db->quote($folderPathWithWildcard) . '
               AND substr(`path`, ' . (strlen($folderPath) + 1) . ') NOT LIKE "%/%"
               AND path != ' . $db->quote($folderPath) . '
          ORDER BY `type` DESC, `path` ASC';
        $stmt = $this->getDbStatement($sql);

        $documents = $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
        foreach ($documents as $key => $document) {
			$documents = $this->setAssetsToDocumentFolders($document, $db, $documents, $key);
        }
        return $documents;
    }


    /**
     * @param $path
     * @return bool|Document
     */
    public function getDocumentContainerByPath($path)
    {
        $document = $this->getDocumentByPath($path, 'unpublished');
        if ($document === false) {
            return false;
        }
        $slugLength = strlen($document->slug);
        $containerPath = substr($path, 0, -$slugLength);
        if ($containerPath === '/') {
            return $this->getRootFolder();
        }
        if (substr($containerPath, -1) === '/'){
			$containerPath = substr($containerPath, 0, -1);
		}
        $containerFolder = $this->getDocumentByPath($containerPath, 'unpublished');
        return $containerFolder;
    }

	/**
	 * @param        $path
	 * @param string $state
	 *
	 * @return bool|\CloudControl\Cms\storage\Document
	 * @throws \Exception
	 */
    public function getDocumentByPath($path, $state = 'published')
    {
		if (!in_array($state, Document::$DOCUMENT_STATES)) {
			throw new \Exception('Unsupported document state: ' . $state);
		}
        $db = $this->getContentDbHandle();
        $document = $this->fetchDocument('
            SELECT *
              FROM documents_' .  $state . '
             WHERE path = ' . $db->quote($path) . '
        ');
        if ($document instanceof Document && $document->type === 'folder') {
            $document->dbHandle = $db;
            $document->documentStorage = new DocumentStorage($this);
        }
        return $document;
    }

	/**
	 * Returns the count of all documents stored in the db
	 *
	 * @param string $state
	 *
	 * @return int
	 * @throws \Exception
	 */
	public function getTotalDocumentCount($state = 'published')
	{
		if (!in_array($state, Document::$DOCUMENT_STATES)) {
			throw new \Exception('Unsupported document state: ' . $state);
		}
		$db = $this->getContentDbHandle();
		$stmt = $db->query('
			SELECT count(*)
			  FROM documents_' . $state . '
			 WHERE `type` != "folder"
		');
		$result = $stmt->fetch(\PDO::FETCH_ASSOC);
		if (!is_array($result )) {
			return 0;
		}
		return intval(current($result));
	}

	public function getPublishedDocumentsNoFolders()
	{
		$db = $this->getContentDbHandle();
		$sql = '
			SELECT *
			  FROM documents_published
			 WHERE `type` != "folder"
		';
		$stmt = $db->query($sql);
		$result = $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
		if ($stmt === false || !$stmt->execute()) {

			$errorInfo = $db->errorInfo();
			$errorMsg = $errorInfo[2];
			throw new \Exception('SQLite Exception: ' . $errorMsg . ' in SQL: <br /><pre>' . $sql . '</pre>');
		}
		return $result;
	}

	private function publishOrUnpublishDocumentByPath($path, $publish = true) {
		if ($publish) {
			$sql = '
				INSERT OR REPLACE INTO documents_published 
					  (`id`,`path`,`title`,`slug`,`type`,`documentType`,`documentTypeSlug`,`state`,`lastModificationDate`,`creationDate`,`publicationDate`,`lastModifiedBy`,`fields`,`bricks`,`dynamicBricks`)
				SELECT `id`,`path`,`title`,`slug`,`type`,`documentType`,`documentTypeSlug`,"published" as state,`lastModificationDate`,`creationDate`,' . time() . ' as publicationDate, `lastModifiedBy`,`fields`,`bricks`,`dynamicBricks`
				  FROM documents_unpublished
				 WHERE `path` = :path
			';
		} else {
			$sql = 'DELETE FROM documents_published
					  WHERE `path` = :path';
		}
		$db = $this->getContentDbHandle();
		$stmt = $db->prepare($sql);
		if ($stmt === false) {

			$errorInfo = $db->errorInfo();
			$errorMsg = $errorInfo[2];
			throw new \Exception('SQLite Exception: ' . $errorMsg . ' in SQL: <br /><pre>' . $sql . '</pre>');
		}
		$stmt->bindValue(':path', $path);
		$stmt->execute();
	}

	public function publishDocumentByPath($path)
	{
		$this->publishOrUnpublishDocumentByPath($path);
	}

	public function unpublishDocumentByPath($path)
	{
		$this->publishOrUnpublishDocumentByPath($path, false);
	}

	public function cleanPublishedDeletedDocuments()
	{
		$sql = '   DELETE FROM documents_published
						 WHERE documents_published.path IN (
						SELECT documents_published.path
						  FROM documents_published
					 LEFT JOIN documents_unpublished
							ON documents_unpublished.path = documents_published.path
						 WHERE documents_unpublished.path IS NULL
		)';
		$stmt = $this->getDbStatement($sql);
		$stmt->execute();
	}

	/**
     * Return the results of the query as array of Documents
     * @param $sql
     * @return array
     * @throws \Exception
     */
    protected function fetchAllDocuments($sql)
    {
        $stmt = $this->getDbStatement($sql);
        return $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
    }

    /**
     * Return the result of the query as Document
     * @param $sql
     * @return mixed
     * @throws \Exception
     */
    protected function fetchDocument($sql)
    {
        $stmt = $this->getDbStatement($sql);
        return $stmt->fetchObject('\CloudControl\Cms\storage\Document');
    }

    /**
     * Prepare the sql statement
     * @param $sql
     * @return \PDOStatement
     * @throws \Exception
     */
    protected function getDbStatement($sql)
    {
        $db = $this->getContentDbHandle();
        $stmt = $db->query($sql);
        if ($stmt === false) {

            $errorInfo = $db->errorInfo();
            $errorMsg = $errorInfo[2];
            throw new \Exception('SQLite Exception: ' . $errorMsg . ' in SQL: <br /><pre>' . $sql . '</pre>');
        }
        return $stmt;
    }

    /**
     * Create a (non-existent) root folder Document and return it
     * @return Document
     */
    protected function getRootFolder()
    {
        $rootFolder = new Document();
        $rootFolder->path = '/';
        $rootFolder->type = 'folder';
        return $rootFolder;
    }

	/**
	 * Save the document to the database
	 *
	 * @param Document $documentObject
	 * @param string   $state
	 *
	 * @return bool
	 * @throws \Exception
	 * @internal param $path
	 */
    public function saveDocument($documentObject, $state = 'published')
    {
		if (!in_array($state, Document::$DOCUMENT_STATES)) {
			throw new \Exception('Unsupported document state: ' . $state);
		}
        $db = $this->getContentDbHandle();
        $stmt = $this->getDbStatement('
            INSERT OR REPLACE INTO documents_' . $state . ' (`path`,`title`,`slug`,`type`,`documentType`,`documentTypeSlug`,`state`,`lastModificationDate`,`creationDate`,`lastModifiedBy`,`fields`,`bricks`,`dynamicBricks`)
            VALUES(
              ' . $db->quote($documentObject->path) . ',
              ' . $db->quote($documentObject->title) . ',
              ' . $db->quote($documentObject->slug) . ',
              ' . $db->quote($documentObject->type) . ',
              ' . $db->quote($documentObject->documentType) . ',
              ' . $db->quote($documentObject->documentTypeSlug) . ',
              ' . $db->quote($documentObject->state) . ',
              ' . $db->quote($documentObject->lastModificationDate) . ',
              ' . $db->quote($documentObject->creationDate) . ',
              ' . $db->quote($documentObject->lastModifiedBy) . ',
              ' . $db->quote(json_encode($documentObject->fields)) . ',
              ' . $db->quote(json_encode($documentObject->bricks)) . ',
              ' . $db->quote(json_encode($documentObject->dynamicBricks)) . '
            )
        ');
        $result = $stmt->execute();
        return $result;
    }

	/**
	 * Delete the document from the database
	 * If it's a folder, also delete it's contents
	 *
	 * @param        $path
	 *
	 * @internal param string $state
	 *
	 */
    public function deleteDocumentByPath($path)
    {
        $db = $this->getContentDbHandle();
        $documentToDelete = $this->getDocumentByPath($path, 'unpublished');
        if ($documentToDelete instanceof Document) {
            if ($documentToDelete->type == 'document') {
                $stmt = $this->getDbStatement('
                    DELETE FROM documents_unpublished
                          WHERE path = ' . $db->quote($path) . '
                ');
                $stmt->execute();
            } elseif ($documentToDelete->type == 'folder') {
                $folderPathWithWildcard = $path . '%';
                $stmt = $this->getDbStatement('
                    DELETE FROM documents_unpublished
                          WHERE (path LIKE ' . $db->quote($folderPathWithWildcard) . '
                            AND substr(`path`, ' . (strlen($path) + 1) . ', 1) = "/")
                            OR path = ' . $db->quote($path) . '
                ');
                $stmt->execute();
            }
        }
    }

	/**
	 * @param $document
	 * @param $db
	 * @param $documents
	 * @param $key
	 *
	 * @return mixed
	 */
	private function setAssetsToDocumentFolders($document, $db, $documents, $key)
	{
		if ($document->type === 'folder') {
			$document->dbHandle = $db;
			$document->documentStorage = new DocumentStorage($this);
			$documents[$key] = $document;
		}

		return $documents;
	}
}

1		<?php
2		/**
3		* User: Jens
4		* Date: 30-1-2017
5		* Time: 20:15
6		*/
7
8		namespace CloudControl\Cms\storage;
9		use CloudControl\Cms\storage\storage\DocumentStorage;
10
11		/**
12		* Class Repository
13		* @package CloudControl\Cms\storage
14		* @property array sitemap
15		* @property array applicationComponents
16		* @property array documentTypes
17		* @property array bricks
18		* @property array imageSet
19		* @property array images
20		* @property array files
21		* @property array users
22		* @property array valuelists
23		* @property array redirects
24		*/
25		class Repository
26		{
27		protected $storagePath;
28
29		protected $fileBasedSubsets = array('sitemap', 'applicationComponents', 'documentTypes', 'bricks', 'imageSet', 'images', 'files', 'users', 'valuelists', 'redirects');
30
31		protected $sitemap;
32		protected $sitemapChanges = false;
33
34		protected $applicationComponents;
35		protected $applicationComponentsChanges = false;
36
37		protected $documentTypes;
38		protected $documentTypesChanges = false;
39
40		protected $bricks;
41		protected $bricksChanges = false;
42
43		protected $imageSet;
44		protected $imageSetChanges = false;
45
46		protected $images;
47		protected $imagesChanges = false;
48
49		protected $files;
50		protected $filesChanges = false;
51
52		protected $users;
53		protected $usersChanges = false;
54
55		protected $valuelists;
56		protected $valuelistsChanges = false;
57
58		protected $redirects;
59		protected $redirectsChanges = false;
60
61		protected $contentDbHandle;
62
63
64		/**
65		* Repository constructor.
66		* @param $storagePath
67		* @throws \Exception
68		*/
69		public function __construct($storagePath)
70		{
71		$storagePath = realpath($storagePath);
72		if (is_dir($storagePath) && $storagePath !== false) {
73		$this->storagePath = $storagePath;
74		} else {
75		throw new \Exception('Repository not yet initialized.');
76		}
77		}
78
79		/**
80		* Creates the folder in which to create all storage related files
81		*
82		* @param $storagePath
83		* @return bool
84		*/
85		public static function create($storagePath)
86		{
87		return mkdir($storagePath);
88		}
89
90		/**
91		* Initiates default storage
92		* @param $baseStorageDefaultPath
93		* @param $baseStorageSqlPath
94		*/
95		public function init($baseStorageDefaultPath, $baseStorageSqlPath)
96		{
97		// TODO Make sure storage isnt overwritten when its already initialized
98		$storageDefaultPath = realpath($baseStorageDefaultPath);
99		$contentSqlPath = realpath($baseStorageSqlPath);
100
101		$this->initConfigStorage($storageDefaultPath);
102		$this->initContentDb($contentSqlPath);
103
104		$this->save();
105		}
106
107		/**
108		* Load filebased subset and return it's contents
109		*
110		* @param $name
111		* @return mixed\|string
112		* @throws \Exception
113		*/
114		public function __get($name)
115		{
116		if (isset($this->$name)) {
117	View Code Duplication	if (in_array($name, $this->fileBasedSubsets)) {
		0 ignored issues – show Duplication introduced 2017-02-17 15:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
118		return $this->$name;
119		} else {
120		throw new \Exception('Trying to get undefined property from Repository: ' . $name);
121		}
122	View Code Duplication	} else {
		0 ignored issues – show Duplication introduced 2017-02-17 15:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
123		if (in_array($name, $this->fileBasedSubsets)) {
124		return $this->loadSubset($name);
125		} else {
126		throw new \Exception('Trying to get undefined property from Repository: ' . $name);
127		}
128		}
129		}
130
131		/**
132		* Set filebased subset contents
133		* @param $name
134		* @param $value
135		* @throws \Exception
136		*/
137		public function __set($name, $value)
138		{
139		if (in_array($name, $this->fileBasedSubsets)) {
140		$this->$name = $value;
141		$changes = $name . 'Changes';
142		$this->$changes = true;
143		} else {
144		throw new \Exception('Trying to persist unknown subset in repository: ' . $name . ' <br /><pre>' . print_r($value, true) . '</pre>');
145		}
146		}
147
148		/**
149		* Persist all subsets
150		*/
151		public function save()
152		{
153		$host = $this;
154		array_map(function ($value) use ($host) {
155		$host->saveSubset($value);
156		}, $this->fileBasedSubsets);
157		}
158
159		/**
160		* Persist subset to disk
161		* @param $subset
162		*/
163		public function saveSubset($subset)
164		{
165		$changes = $subset . 'Changes';
166		if ($this->$changes === true) {
167		if (!defined('JSON_PRETTY_PRINT')) {
168		$json = json_encode($this->$subset);
169		} else {
170		$json = json_encode($this->$subset, JSON_PRETTY_PRINT);
171		}
172		$subsetStoragePath = $this->storagePath . DIRECTORY_SEPARATOR . $subset . '.json';
173		file_put_contents($subsetStoragePath, $json);
174
175		$this->$changes = false;
176		}
177		}
178
179		/**
180		* Load subset from disk
181		* @param $subset
182		* @return mixed\|string
183		*/
184		protected function loadSubset($subset)
185		{
186		$subsetStoragePath = $this->storagePath . DIRECTORY_SEPARATOR . $subset . '.json';
187		$json = file_get_contents($subsetStoragePath);
188		$json = json_decode($json);
189		$this->$subset = $json;
190		return $json;
191		}
192
193		/**
194		* @param $contentSqlPath
195		*/
196		protected function initContentDb($contentSqlPath)
197		{
198		$db = $this->getContentDbHandle();
199		$sql = file_get_contents($contentSqlPath);
200		$db->exec($sql);
201		}
202
203		/**
204		* @param $storageDefaultPath
205		*/
206		protected function initConfigStorage($storageDefaultPath)
207		{
208		$json = file_get_contents($storageDefaultPath);
209		$json = json_decode($json);
210		$this->sitemap = $json->sitemap;
211		$this->sitemapChanges = true;
212		$this->applicationComponents = $json->applicationComponents;
213		$this->applicationComponentsChanges = true;
214		$this->documentTypes = $json->documentTypes;
215		$this->documentTypesChanges = true;
216		$this->bricks = $json->bricks;
217		$this->bricksChanges = true;
218		$this->imageSet = $json->imageSet;
219		$this->imageSetChanges = true;
220		$this->images = $json->images;
221		$this->imagesChanges = true;
222		$this->files = $json->files;
223		$this->filesChanges = true;
224		$this->users = $json->users;
225		$this->usersChanges = true;
226		$this->valuelists = $json->valuelists;
227		$this->valuelistsChanges = true;
228		$this->redirects = $json->redirects;
229		$this->redirectsChanges = true;
230		}
231
232		/**
233		* @return \PDO
234		*/
235		public function getContentDbHandle()
236		{
237		if ($this->contentDbHandle === null) {
238		$this->contentDbHandle = new \PDO('sqlite:' . $this->storagePath . DIRECTORY_SEPARATOR . 'content.db');
239		}
240		return $this->contentDbHandle;
241		}
242
243		/**
244		* Get all documents
245		*
246		* @param string $state
247		*
248		* @return array
249		* @throws \Exception
250		*/
251		public function getDocuments($state = 'published')
252		{
253		if (!in_array($state, Document::$DOCUMENT_STATES)) {
254		throw new \Exception('Unsupported document state: ' . $state);
255		}
256		return $this->getDocumentsByPath('/', $state);
257		}
258
259		public function getDocumentsWithState($folderPath = '/')
260		{
261		$db = $this->getContentDbHandle();
262		$folderPathWithWildcard = $folderPath . '%';
263
264		$ifRootIndex = 1;
265		if ($folderPath == '/') {
266		$ifRootIndex = 0;
267		}
268
269		$sql = '
270		SELECT documents_unpublished.*,
271		IFNULL(documents_published.state,"unpublished") as state,
272		IFNULL(documents_published.publicationDate,NULL) as publicationDate,
273		(documents_published.lastModificationDate != documents_unpublished.lastModificationDate) as unpublishedChanges
274		FROM documents_unpublished
275		LEFT JOIN documents_published
276		ON documents_published.path = documents_unpublished.path
277		WHERE documents_unpublished.`path` LIKE ' . $db->quote($folderPathWithWildcard) . '
278		AND substr(documents_unpublished.`path`, ' . (strlen($folderPath) + $ifRootIndex + 1) . ') NOT LIKE "%/%"
279		AND length(documents_unpublished.`path`) > ' . (strlen($folderPath) + $ifRootIndex) . '
280		AND documents_unpublished.path != ' . $db->quote($folderPath) . '
281		ORDER BY documents_unpublished.`type` DESC, documents_unpublished.`path` ASC
282		';
283		$stmt = $this->getDbStatement($sql);
284
285
286
287		$documents = $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
288		foreach ($documents as $key => $document) {
289		$documents = $this->setAssetsToDocumentFolders($document, $db, $documents, $key);
290		}
291		//dump($documents);
292		return $documents;
293		}
294
295		/**
296		* Get all documents and folders in a certain path
297		*
298		* @param $folderPath
299		* @param string $state
300		*
301		* @return array
302		* @throws \Exception
303		*/
304		public function getDocumentsByPath($folderPath, $state = 'published')
305		{
306		if (!in_array($state, Document::$DOCUMENT_STATES)) {
307		throw new \Exception('Unsupported document state: ' . $state);
308		}
309		$db = $this->getContentDbHandle();
310		$folderPathWithWildcard = $folderPath . '%';
311
312		$sql = 'SELECT *
313		FROM documents_' . $state . '
314		WHERE `path` LIKE ' . $db->quote($folderPathWithWildcard) . '
315		AND substr(`path`, ' . (strlen($folderPath) + 1) . ') NOT LIKE "%/%"
316		AND path != ' . $db->quote($folderPath) . '
317		ORDER BY `type` DESC, `path` ASC';
318		$stmt = $this->getDbStatement($sql);
319
320		$documents = $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
321		foreach ($documents as $key => $document) {
322		$documents = $this->setAssetsToDocumentFolders($document, $db, $documents, $key);
323		}
324		return $documents;
325		}
326
327
328		/**
329		* @param $path
330		* @return bool\|Document
331		*/
332		public function getDocumentContainerByPath($path)
333		{
334		$document = $this->getDocumentByPath($path, 'unpublished');
335		if ($document === false) {
336		return false;
337		}
338		$slugLength = strlen($document->slug);
339		$containerPath = substr($path, 0, -$slugLength);
340		if ($containerPath === '/') {
341		return $this->getRootFolder();
342		}
343		if (substr($containerPath, -1) === '/'){
344		$containerPath = substr($containerPath, 0, -1);
345		}
346		$containerFolder = $this->getDocumentByPath($containerPath, 'unpublished');
347		return $containerFolder;
348		}
349
350		/**
351		* @param $path
352		* @param string $state
353		*
354		* @return bool\|\CloudControl\Cms\storage\Document
355		* @throws \Exception
356		*/
357		public function getDocumentByPath($path, $state = 'published')
358		{
359		if (!in_array($state, Document::$DOCUMENT_STATES)) {
360		throw new \Exception('Unsupported document state: ' . $state);
361		}
362		$db = $this->getContentDbHandle();
363		$document = $this->fetchDocument('
364		SELECT *
365		FROM documents_' . $state . '
366		WHERE path = ' . $db->quote($path) . '
367		');
368		if ($document instanceof Document && $document->type === 'folder') {
369		$document->dbHandle = $db;
370		$document->documentStorage = new DocumentStorage($this);
371		}
372		return $document;
373		}
374
375		/**
376		* Returns the count of all documents stored in the db
377		*
378		* @param string $state
379		*
380		* @return int
381		* @throws \Exception
382		*/
383		public function getTotalDocumentCount($state = 'published')
384		{
385		if (!in_array($state, Document::$DOCUMENT_STATES)) {
386		throw new \Exception('Unsupported document state: ' . $state);
387		}
388		$db = $this->getContentDbHandle();
389		$stmt = $db->query('
390		SELECT count(*)
391		FROM documents_' . $state . '
392		WHERE `type` != "folder"
393		');
394		$result = $stmt->fetch(\PDO::FETCH_ASSOC);
395		if (!is_array($result )) {
396		return 0;
397		}
398		return intval(current($result));
399		}
400
401		public function getPublishedDocumentsNoFolders()
402		{
403		$db = $this->getContentDbHandle();
404		$sql = '
405		SELECT *
406		FROM documents_published
407		WHERE `type` != "folder"
408		';
409		$stmt = $db->query($sql);
410		$result = $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
411	View Code Duplication	if ($stmt === false \|\| !$stmt->execute()) {
		0 ignored issues – show Duplication introduced 2017-08-23 14:34 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
412		$errorInfo = $db->errorInfo();
413		$errorMsg = $errorInfo[2];
414		throw new \Exception('SQLite Exception: ' . $errorMsg . ' in SQL: <br /><pre>' . $sql . '</pre>');
415		}
416		return $result;
417		}
418
419		private function publishOrUnpublishDocumentByPath($path, $publish = true) {
420		if ($publish) {
421		$sql = '
422		INSERT OR REPLACE INTO documents_published
423		(`id`,`path`,`title`,`slug`,`type`,`documentType`,`documentTypeSlug`,`state`,`lastModificationDate`,`creationDate`,`publicationDate`,`lastModifiedBy`,`fields`,`bricks`,`dynamicBricks`)
424		SELECT `id`,`path`,`title`,`slug`,`type`,`documentType`,`documentTypeSlug`,"published" as state,`lastModificationDate`,`creationDate`,' . time() . ' as publicationDate, `lastModifiedBy`,`fields`,`bricks`,`dynamicBricks`
425		FROM documents_unpublished
426		WHERE `path` = :path
427		';
428		} else {
429		$sql = 'DELETE FROM documents_published
430		WHERE `path` = :path';
431		}
432		$db = $this->getContentDbHandle();
433		$stmt = $db->prepare($sql);
434	View Code Duplication	if ($stmt === false) {
		0 ignored issues – show Duplication introduced 2017-02-17 15:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
435		$errorInfo = $db->errorInfo();
436		$errorMsg = $errorInfo[2];
437		throw new \Exception('SQLite Exception: ' . $errorMsg . ' in SQL: <br /><pre>' . $sql . '</pre>');
438		}
439		$stmt->bindValue(':path', $path);
440		$stmt->execute();
441		}
442
443		public function publishDocumentByPath($path)
444		{
445		$this->publishOrUnpublishDocumentByPath($path);
446		}
447
448		public function unpublishDocumentByPath($path)
449		{
450		$this->publishOrUnpublishDocumentByPath($path, false);
451		}
452
453		public function cleanPublishedDeletedDocuments()
454		{
455		$sql = ' DELETE FROM documents_published
456		WHERE documents_published.path IN (
457		SELECT documents_published.path
458		FROM documents_published
459		LEFT JOIN documents_unpublished
460		ON documents_unpublished.path = documents_published.path
461		WHERE documents_unpublished.path IS NULL
462		)';
463		$stmt = $this->getDbStatement($sql);
464		$stmt->execute();
465		}
466
467		/**
468		* Return the results of the query as array of Documents
469		* @param $sql
470		* @return array
471		* @throws \Exception
472		*/
473		protected function fetchAllDocuments($sql)
474		{
475		$stmt = $this->getDbStatement($sql);
476		return $stmt->fetchAll(\PDO::FETCH_CLASS, '\CloudControl\Cms\storage\Document');
477		}
478
479		/**
480		* Return the result of the query as Document
481		* @param $sql
482		* @return mixed
483		* @throws \Exception
484		*/
485		protected function fetchDocument($sql)
486		{
487		$stmt = $this->getDbStatement($sql);
488		return $stmt->fetchObject('\CloudControl\Cms\storage\Document');
489		}
490
491		/**
492		* Prepare the sql statement
493		* @param $sql
494		* @return \PDOStatement
495		* @throws \Exception
496		*/
497		protected function getDbStatement($sql)
498		{
499		$db = $this->getContentDbHandle();
500		$stmt = $db->query($sql);
501	View Code Duplication	if ($stmt === false) {
		0 ignored issues – show Duplication introduced 2017-08-23 14:34 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
502		$errorInfo = $db->errorInfo();
503		$errorMsg = $errorInfo[2];
504		throw new \Exception('SQLite Exception: ' . $errorMsg . ' in SQL: <br /><pre>' . $sql . '</pre>');
505		}
506		return $stmt;
507		}
508
509		/**
510		* Create a (non-existent) root folder Document and return it
511		* @return Document
512		*/
513		protected function getRootFolder()
514		{
515		$rootFolder = new Document();
516		$rootFolder->path = '/';
517		$rootFolder->type = 'folder';
518		return $rootFolder;
519		}
520
521		/**
522		* Save the document to the database
523		*
524		* @param Document $documentObject
525		* @param string $state
526		*
527		* @return bool
528		* @throws \Exception
529		* @internal param $path
530		*/
531		public function saveDocument($documentObject, $state = 'published')
532		{
533		if (!in_array($state, Document::$DOCUMENT_STATES)) {
534		throw new \Exception('Unsupported document state: ' . $state);
535		}
536		$db = $this->getContentDbHandle();
537		$stmt = $this->getDbStatement('
538		INSERT OR REPLACE INTO documents_' . $state . ' (`path`,`title`,`slug`,`type`,`documentType`,`documentTypeSlug`,`state`,`lastModificationDate`,`creationDate`,`lastModifiedBy`,`fields`,`bricks`,`dynamicBricks`)
539		VALUES(
540		' . $db->quote($documentObject->path) . ',
541		' . $db->quote($documentObject->title) . ',
542		' . $db->quote($documentObject->slug) . ',
543		' . $db->quote($documentObject->type) . ',
544		' . $db->quote($documentObject->documentType) . ',
545		' . $db->quote($documentObject->documentTypeSlug) . ',
546		' . $db->quote($documentObject->state) . ',
547		' . $db->quote($documentObject->lastModificationDate) . ',
548		' . $db->quote($documentObject->creationDate) . ',
549		' . $db->quote($documentObject->lastModifiedBy) . ',
550		' . $db->quote(json_encode($documentObject->fields)) . ',
551		' . $db->quote(json_encode($documentObject->bricks)) . ',
552		' . $db->quote(json_encode($documentObject->dynamicBricks)) . '
553		)
554		');
555		$result = $stmt->execute();
556		return $result;
557		}
558
559		/**
560		* Delete the document from the database
561		* If it's a folder, also delete it's contents
562		*
563		* @param $path
564		*
565		* @internal param string $state
566		*
567		*/
568		public function deleteDocumentByPath($path)
569		{
570		$db = $this->getContentDbHandle();
571		$documentToDelete = $this->getDocumentByPath($path, 'unpublished');
572		if ($documentToDelete instanceof Document) {
573		if ($documentToDelete->type == 'document') {
574		$stmt = $this->getDbStatement('
575		DELETE FROM documents_unpublished
576		WHERE path = ' . $db->quote($path) . '
577		');
578		$stmt->execute();
579		} elseif ($documentToDelete->type == 'folder') {
580		$folderPathWithWildcard = $path . '%';
581		$stmt = $this->getDbStatement('
582		DELETE FROM documents_unpublished
583		WHERE (path LIKE ' . $db->quote($folderPathWithWildcard) . '
584		AND substr(`path`, ' . (strlen($path) + 1) . ', 1) = "/")
585		OR path = ' . $db->quote($path) . '
586		');
587		$stmt->execute();
588		}
589		}
590		}
591
592		/**
593		* @param $document
594		* @param $db
595		* @param $documents
596		* @param $key
597		*
598		* @return mixed
599		*/
600		private function setAssetsToDocumentFolders($document, $db, $documents, $key)
601		{
602		if ($document->type === 'folder') {
603		$document->dbHandle = $db;
604		$document->documentStorage = new DocumentStorage($this);
605		$documents[$key] = $document;
606		}
607
608		return $documents;
609		}
610		}

jenskooij / cloudcontrol

Push — master ( 9c6499...c22bc5 )

Repository::initContentDb() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like