kishanjasani / SociaManager

zipper.php

<?php


/** 

 * Copyright 2018 Social Manager.

 * PHP version 7.2.8

 *

 * It will Zip the file

 * 

 * @category Album_Manager

 * @package  Zipper

 * @author   Kishan Jasani <kishanjasani007@yahoo.in>

 * @license  https://rtfbchallenge.tk/privacy_policy/privacy_policy.php 

 * @link     ""

 * 

 * You are hereby granted a non-exclusive, worldwide, royalty-free license to

 * use, copy, modify, and distribute this software in source code or binary

 * form for use in connection with the web services and APIs provided by

 * Kishan Jasani.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND

 */

$zip_folder = "";

/** 

 * Starting of zipping folders recursively 

 */


class Zipper

{

    /**

     * It will load the file which willl zip

     * 

     * @param String $source Source of the folder

     * 

     * @return $a

The doc comment $a at position 0 could not be parsed: Unknown type name '$a' at position 0 in $a.

     */

    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;

                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 

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;

    }

    /**

     * It will process the zip

     * 

     * @param String $foldercontent content of the folder

     * @param String $folder        folder name

     * @param String $maxsize       maximum size of the folder

     * 

     * @return array

     */

    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) {

The expression $foldercontent of type string is not traversable.

                $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;

The expression return false returns the type false which is incompatible with the documented return type array.

                }

                $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', 

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

                            file_get_contents($entry['file'])

                        );

                        $i++;

                    }

                }

                $zip->close();

            }

            return array(

                'splits' => count($split),

                'foldername' => ''

            );

        }

    }

    /**

     * It will get the memory limit

     * 

     * @return "$memory_limit"

The doc comment "$memory_limit" at position 0 could not be parsed: Unknown type name '"$memory_limit"' at position 0 in "$memory_limit".

     */

    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;

    }


    /**

     * It will Make the zip

     * 

     * @param String $album_download_directory folder will be zip 

     * 

     * @return $zipfilename

The doc comment $zipfilename at position 0 could not be parsed: Unknown type name '$zipfilename' at position 0 in $zipfilename.

     */

    public function makeZip($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 = 'public/fb-album_'.date("Y-m-d").'_'.date("H-i-s");

            

            $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);

$foldercontent of type array<mixed,array<string,integer|string|mixed>> is incompatible with the type string expected by parameter $foldercontent of Zipper::processZip().

            if ($zip === false) {

The condition $zip === false is always false.

                echo 'Something went wrong zipping the files';

            }    

            // clear the stat cache (created by filesize command)

            clearstatcache();

            include_once 'Unlink_Directory.php';

            $unlink_directory = new Unlink_Directory();

            $unlink_directory->removeDirectory($album_download_directory);

        }

        return $zipfilename;

    }

    /**

     * It will get the zip file

     * 

     * @param String $album_download_directory folder will be zip 

     * 

     * @return $response

The doc comment $response at position 0 could not be parsed: Unknown type name '$response' at position 0 in $response.

     */

    public function getZip($album_download_directory) 

    {

        $response = '<span style="color: #ffffff;">Sorry due to some reasons albums is not downloaded.</span>';

        if (isset($album_download_directory)) {

            $zip_folder = $this->makeZip($album_download_directory);

            if (!empty($zip_folder)) {

                $response = $zip_folder;

            }

        }

        return $response;

    }

}

?>

It is not recommended to use PHP's closing tag ?> in files other than templates.