faveo/app/FaveoStorage/Controllers/StorageController.php

<?php

namespace App\FaveoStorage\Controllers;

use App\Http\Controllers\Controller;
use App\Model\helpdesk\Settings\CommonSettings;
use App\Model\helpdesk\Ticket\Ticket_attachments;
use App\Model\helpdesk\Ticket\Ticket_Thread;
use Config;
use Storage;

class StorageController extends Controller {

    protected $default;
    protected $driver;
    protected $root;
    protected $s3_key;
    protected $s3_region;
    protected $s3_secret;
    protected $s3_bucket;
    protected $rackspace_key;
    protected $rackspace_region;
    protected $rackspace_username;
    protected $rackspace_container;
    protected $rackspace_endpoint;
    protected $rackspace_url_type;

    public function __construct() {
        $this->default = $this->defaults();
        $this->driver = $this->driver();
        $this->root = $this->root();
        $this->s3_key = $this->s3Key();
        $this->s3_region = $this->s3Region();
        $this->s3_bucket = $this->s3Bucket();
        $this->rackspace_container = $this->rackspaceContainer();
        $this->rackspace_endpoint = $this->rackspaceEndpoint();
        $this->rackspace_key = $this->rackspaceKey();
        $this->rackspace_region = $this->rackspaceRegion();
        $this->rackspace_url_type = $this->rackspaceUrlType();
        $this->rackspace_username = $this->rackspaceUsername();
    }

    protected function settings($option) {
        $settings = new CommonSettings();
        $setting = $settings->getOptionValue('storage', $option);
        $value = '';
        if ($setting) {
            $value = $setting->option_value;
        }

        return $value;
    }

    public function defaults() {
        $default = 'local';
        if ($this->settings('default')) {
            $default = $this->settings('default');
        }

        return $default;
    }

    public function driver() {
        return $this->settings('default');
    }

    public function root() {
        $root = storage_path('app');
        if ($this->settings('root')) {
            $root = $this->settings('root');
        }

        return $root;
    }

    public function s3Key() {
        return $this->settings('s3_key');
    }

    public function s3Region() {
        return $this->settings('s3_region');
    }

    public function s3Secret() {
        return $this->settings('s3_secret');
    }

    public function s3Bucket() {
        return $this->settings('s3_bucket');
    }

    public function rackspaceKey() {
        return $this->settings('root');
    }

    public function rackspaceRegion() {
        return $this->settings('rackspace_region');
    }

    public function rackspaceUsername() {
        return $this->settings('rackspace_username');
    }

    public function rackspaceContainer() {
        return $this->settings('rackspace_container');
    }

    public function rackspaceEndpoint() {
        return $this->settings('rackspace_endpoint');
    }

    public function rackspaceUrlType() {
        return $this->settings('rackspace_url_type');
    }

    protected function setFileSystem() {
        $config = $this->config();
        //dd($config);
        foreach ($config as $key => $con) {
            if (is_array($con)) {
                foreach ($con as $k => $v) {
                    Config::set("filesystem.$key.$k", $v);
                }
            }
            Config::set("filesystem.$key", $con);
        }

        return Config::get('filesystem');
    }

    protected function config() {
        return [
            'default' => $this->default,
            'cloud' => 's3',
            'disks' => $this->disks(),
        ];
    }

    protected function disks() {
        return [
            'local' => [
                'driver' => 'local',
                'root' => $this->root . '/attachments',
            ],
            's3' => [
                'driver' => 's3',
                'key' => $this->s3_key,
                'secret' => $this->s3_secret,
                'region' => $this->s3_region,
                'bucket' => $this->s3_bucket,
            ],
            'rackspace' => [
                'driver' => 'rackspace',
                'username' => $this->rackspace_username,
                'key' => $this->rackspace_key,
                'container' => $this->rackspace_container,
                'endpoint' => $this->rackspace_endpoint,
                'region' => $this->rackspace_region,
                'url_type' => $this->rackspace_url_type,
            ],
        ];
    }

    public function upload($data, $filename, $type, $size, $disposition, $thread_id) {
        $upload = new Ticket_attachments();
        $upload->thread_id = $thread_id;
        $upload->name = $filename;
        $upload->type = $type;
        $upload->size = $size;
        $upload->poster = $disposition;
        $upload->driver = $this->default;
        $upload->path = $this->root. DIRECTORY_SEPARATOR.'attachments';
        if ($this->default !== 'database') {
            $this->setFileSystem();
            Storage::disk($this->default)->put($filename, $data);
            $storagePath = Storage::disk($this->default)->getDriver()->getAdapter()->getPathPrefix() . $filename;
            if (mime(\File::mimeType($storagePath)) != 'image' || mime(\File::extension($storagePath)) != 'image') {
                chmod($storagePath, 1204);
            }
        } else {
            $upload->file = $data;
        }
        if ($data && $size && $disposition) {
            $upload->save();
        }
    }

    public function saveAttachments($thread_id, $attachments = []) {
        $disposition = 'ATTACHMENT';
        $thread = '';
        foreach ($attachments as $attachment) {
            if (is_object($attachment)) {
                if (method_exists($attachment, 'getStructure')) {

                    $structure = $attachment->getStructure();
                    if (isset($structure->disposition)) {
                        $disposition = $structure->disposition;
                    }
                    $filename = rand(1111, 9999) . "_" . $attachment->getFileName();
                    $type = $attachment->getMimeType();
                    $size = $attachment->getSize();
                    $data = $attachment->getData();
                } else {
                    $filename = rand(1111, 9999) . "_" . $attachment->getClientOriginalName();
                    $type = $attachment->getMimeType();
                    $size = $attachment->getSize();
                    $data = file_get_contents($attachment->getRealPath());
                }
                $this->upload($data, $filename, $type, $size, $disposition, $thread_id);
                $thread = $this->updateBody($attachment, $thread_id, $filename);
            }
        }
        return $thread;
    }

    public function updateBody($attachment, $thread_id, $filename) {
        $threads = new Ticket_Thread();
        $thread = $threads->find($thread_id);
        $disposition = 'ATTACHMENT';
        if (is_object($attachment)) {
            if (method_exists($attachment, 'getStructure')) {
                $structure = $attachment->getStructure();
                if (isset($structure->disposition)) {
                    $disposition = $structure->disposition;
                }
            }
        }
        
        if ($disposition == 'INLINE' || $disposition == 'inline') {
            $id = str_replace('>', '', str_replace('<', '', $structure->id));
            $body = $thread->body;
           // dd($id,$filename,$body);
            $body = str_replace('cid:' . $id, $filename, $body);
           // dd($body);
            $thread->body = $body;
            $thread->save();
        }
        return $thread;
    }

    public function getFile($drive, $name, $root) {
        if ($drive != "database") {
            $root = $root . DIRECTORY_SEPARATOR . $name;
            if (\File::exists($root)) {
                chmod($root, 0755);
                return \File::get($root);
            }
        }
    }

}