zipper

Complexity

Total Complexity

30

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
B	ProcessZip()	0	66	10
A	getMemoryLimit()	0	12	4
B	LoadZipFiles()	0	44	8
A	make_zip()	0	49	5
A	get_zip()	0	9	3

<?php

//============  Start of file Ziping function Code ===========================================================//

$zip_folder = "";

class zipper {

	public function LoadZipFiles($source) {

		if (!file_exists($source)) {
			return false;
		}

		$source = str_replace('\\', '/', realpath($source));

		$a = array();

		if (is_dir($source) === true) {
			$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($source), RecursiveIteratorIterator::SELF_FIRST);

			foreach ($files as $file) {
				$file = str_replace('\\', '/', $file);

				// Ignore "." and ".." folders
				if (in_array(substr($file, strrpos($file, '/') + 1), array('.', '..')))
					continue;

				$file = realpath($file);

				if (is_dir($file) === true) {
					$a[] = array(
						'type' => 'dir',
						'source' => str_replace($source . '/', '', $file . '/'),
						'file' => $file,
						'size' => 0
					);
				} else if (is_file($file) === true) {
					$src = str_replace($source . '/', '', $file);
					$size = filesize($file);

					$a[] = array(
						'type' => 'file',
						'source' => $src,
						'file' => $file,
						'size' => false != $size ? $size : 16000 // this is fallback in case no size

It seems like you are loosely comparing $size of type integer to the boolean false. If you are specifically checking for non-zero, consider using something more explicit like > 0 or !== 0 instead.

					);
				}
			}
		}

		return $a;
	}

	public function ProcessZip($foldercontent, $folder, $maxsize) {

		$split = array();

		$splits = 1;
		$t = 0;

		// Determine how many zip files to create
		if ( isset( $foldercontent ) ) {
			foreach ($foldercontent as $entry) {
	
				$t = $t + $entry['size'];
	
				if ($entry['type'] == 'dir') {
					$lastdir = $entry;
				}
	
				if ($t >= $maxsize) {
					$splits++;
					$t = 0;
					// create lastdir in next archive, in case files still exist
					// even if the next file is not in this archive it doesn't hurt
					if ($lastdir !== '') {

The variable $lastdir does not seem to be defined for all execution paths leading up to this point.

						$split[$splits][] = $lastdir;
					}
				}
	
				$split[$splits][] = $entry;
			}
	
			// delete the $foldercontent array
			unset($foldercontent);
	
			// Create the folder to put the zip files in
			$date = new DateTime();
			$tS = $date->format('YmdHis');

The assignment to $tS is dead and can be removed.

	
			// Process the splits
			foreach ($split as $idx => $sp) {
				
				// create the zip file
	
				$zip = new ZipArchive();
	
				$destination = $folder . '.zip';
	
				if (!$zip->open($destination, ZIPARCHIVE::CREATE)) {
					return false;
				}
	
				$i = 1;
				$dir = "";
				foreach ($sp as $entry) {
					if ($entry['type'] === 'dir') {
						$dir = explode('\\', $entry['file']);
						$zip->addEmptyDir(end($dir));
					} else {
						$zip->addFromString(end($dir).'/'.$i.'.jpg', file_get_contents($entry['file']));

$dir of type string is incompatible with the type array expected by parameter $array of end().

						$i++;
					}
				}
				$zip->close();
			}
			return array(
				'splits' => count($split),
				'foldername' => ''
			);
		}
	}

	public function getMemoryLimit() {
		$memory_limit = ini_get('memory_limit');

		if (preg_match('/^(\d+)(.)$/', $memory_limit, $matches)) {
			if ($matches[2] == 'M') {
				$memory_limit = $matches[1] * 1024 * 1024; // nnnM -> nnn MB
			} else if ($matches[2] == 'K') {
				$memory_limit = $matches[1] * 1024; // nnnK -> nnn KB
			}
		}

		return $memory_limit;
	}

	public function make_zip($album_download_directory) {
		$zipfilename = "";
		if ( isset( $album_download_directory) ) {
			//$zipfilename = 'libs/resources'.DIRECTORY_SEPARATOR.'albums'.DIRECTORY_SEPARATOR.'fb-album_'.date("Y-m-d").'_'.date("H-i-s");
			$zipfilename = 'lib/resources/albums/fb-album_'.date("Y-m-d").'_'.date("H-i-s");
	
			// name of folder starting from the root of the webserver
			// as in Wordpress /wp-content/themes/ (end on backslash)
	
	
			$folder = dirname($_SERVER['PHP_SELF']).'/'.$album_download_directory;
	
			// Server Root
			$root = $_SERVER["DOCUMENT_ROOT"];
	
			// source of the folder to unpack
			$sourcedir = $root . $folder; // target directory
	
			// Don't use more than half the memory limit
			$memory_limit = $this->getMemoryLimit();
			$maxsize = $memory_limit / 2;
	
			// Is zipping possible on the server ?
			if (!extension_loaded('zip')) {
				echo 'Zipping not possible on this server';
				exit;

Using exit here is not recommended.

			}
	
			// Get the files to zip
			$foldercontent = $this->LoadZipFiles($sourcedir);
			if ($foldercontent === false) {
				echo 'Something went wrong gathering the file entries';
				exit;

Using exit here is not recommended.

			}
	
			// Process the files to zip
			$zip = $this->ProcessZip($foldercontent, $zipfilename, $maxsize);
			if ($zip === false) {
				echo 'Something went wrong zipping the files';
			}
			
			// clear the stat cache (created by filesize command)
			clearstatcache();
			
			require_once( 'unlink_directory.php' );
			$unlink_directory = new unlink_directory();
			$unlink_directory->remove_directory( $album_download_directory );
		}
		return $zipfilename;
	}

	public function get_zip( $album_download_directory ) {
		$response = '<span style="color: #ffffff;">Sorry due to some reasons albums cannot be downloaded.</span>';
		if ( isset( $album_download_directory ) ) {
			$zip_folder = $this->make_zip( $album_download_directory );
			if ( !empty( $zip_folder ) ) {
				$response = '<a href="' . $zip_folder . '.zip" id="download-link" class="btn btn-success link-buttons-border-color" >Download Zip Folder</a>';
			}
		}
		return $response;
	}
}