refactoring part 1

app/Http/Controllers/FileManager/BrowseController.php

@@ -0,0 +1,213 @@
+<?php
+
+namespace App\Http\Controllers\FileManager;
+
+use App\Http\Requests\FileBrowser\SearchRequest;
+use App\Models\User;
+use Illuminate\Support\Facades\Auth;
+use App\Http\Controllers\Controller;
+use Illuminate\Support\Collection;
+use Illuminate\Http\Request;
+use App\Models\Folder;
+use App\Models\File;
+use App\Models\Share;
+
+class BrowseController extends Controller
+{
+
+    /**
+     * Get trashed files
+     *
+     * @return Collection
+     */
+    public function trash()
+    {
+        // Get user id
+        $user_id = Auth::id();
+
+        // Get folders and files
+        $folders_trashed = Folder::onlyTrashed()
+            ->with(['trashed_folders', 'parent'])
+            ->where('user_id', $user_id)
+            ->get(['parent_id', 'id', 'name']);
+
+        $folders = Folder::onlyTrashed()
+            ->with(['parent'])
+            ->where('user_id', $user_id)
+            ->whereIn('id', filter_folders_ids($folders_trashed))
+            ->sortable()
+            ->get();
+
+        // Get files trashed
+        $files_trashed = File::onlyTrashed()
+            ->with(['parent'])
+            ->where('user_id', $user_id)
+            ->whereNull('folder_id')
+            ->orWhereNotIn('folder_id', array_values(array_unique(recursiveFind($folders_trashed->toArray(), 'id'))))
+            ->sortable()
+            ->get();
+
+        // Collect folders and files to single array
+        return collect([$folders, $files_trashed])->collapse();
+    }
+
+    /**
+     * Get user shared items
+     *
+     * @return Collection
+     */
+    public function shared()
+    {
+        // Get user
+        $user_id = Auth::id();
+
+        // Get shared folders and files
+        $folder_ids = Share::where('user_id', $user_id)
+            ->where('type', 'folder')
+            ->pluck('item_id');
+
+        $file_ids = Share::where('user_id', $user_id)
+            ->where('type', '!=', 'folder')
+            ->pluck('item_id');
+
+        // Get folders and files
+        $folders = Folder::with(['parent', 'shared:token,id,item_id,permission,is_protected,expire_in'])
+            ->where('user_id', $user_id)
+            ->whereIn('id', $folder_ids)
+            ->sortable()
+            ->get();
+
+        $files = File::with(['parent', 'shared:token,id,item_id,permission,is_protected,expire_in'])
+            ->where('user_id', $user_id)
+            ->whereIn('id', $file_ids)
+            ->sortable()
+            ->get();
+
+        // Collect folders and files to single array
+        return collect([$folders, $files])->collapse();
+    }
+
+    /**
+     * Get latest user uploads
+     *
+     * @return mixed
+     */
+    public function latest()
+    {
+        $user = User::with(['latest_uploads' => function ($query) {
+            $query->sortable(['created_at' => 'desc']);
+        }])
+            ->where('id', Auth::id())
+            ->first();
+
+        return $user->latest_uploads;
+    }
+
+    /**
+     * Get participant uploads
+     *
+     * @return mixed
+     */
+    public function participant_uploads()
+    {
+
+        // Get User
+        $uploads = File::with(['parent'])
+            ->where('user_id', Auth::id())
+            ->whereUserScope('editor')
+            ->sortable()
+            ->get();
+
+        return $uploads;
+    }
+
+    /**
+     * Get directory with files
+     *
+     * @param Request $request
+     * @param $id
+     * @return Collection
+     */
+    public function folder(Request $request, $id)
+    {
+        // Get folder trash items
+        if ($request->query('trash')) {
+
+            // Get folders and files
+            $folders = Folder::onlyTrashed()
+                ->with('parent')
+                ->where('parent_id', $id)
+                ->sortable()
+                ->get();
+
+            $files = File::onlyTrashed()
+                ->with('parent')
+                ->where('folder_id', $id)
+                ->sortable()
+                ->get();
+
+            // Collect folders and files to single array
+            return collect([$folders, $files])->collapse();
+        }
+
+        // Get folders and files
+        $folders = Folder::with(['parent:id,name', 'shared:token,id,item_id,permission,is_protected,expire_in'])
+            ->where('parent_id', $id)
+            ->sortable()
+            ->get();
+
+        $files = File::with(['parent:id,name', 'shared:token,id,item_id,permission,is_protected,expire_in'])
+            ->where('folder_id', $id)
+            ->sortable()
+            ->get();
+
+        // Collect folders and files to single array
+        return collect([$folders, $files])
+            ->collapse();
+    }
+
+    /**
+     * Get user folder tree
+     *
+     * @return array
+     */
+    public function navigation_tree()
+    {
+        $folders = Folder::with('folders:id,parent_id,id,name')
+            ->where('parent_id', null)
+            ->sortable()
+            ->get(['id', 'parent_id', 'id', 'name']);
+
+        return [
+            [
+                'name'      => __('vuefilemanager.home'),
+                'location'  => 'base',
+                'folders'   => $folders,
+            ]
+        ];
+    }
+
+    /**
+     * Search files
+     *
+     * @param Request $request
+     * @return \Illuminate\Database\Eloquent\Collection
+     */
+    public function search(SearchRequest $request)
+    {
+        // Get user
+        $user_id = Auth::id();
+        $query = remove_accents($request->input('query'));
+
+        // Search files id db
+        $searched_files = File::search($query)
+            ->where('user_id', $user_id)
+            ->get();
+        $searched_folders = Folder::search($query)
+            ->where('user_id', $user_id)
+            ->get();
+
+        // Collect folders and files to single array
+        return collect([$searched_folders, $searched_files])->collapse();
+    }
+}

app/Http/Controllers/FileManager/EditItemsController.php

@@ -0,0 +1,573 @@
+<?php
+
+namespace App\Http\Controllers\FileManager;
+
+use App\Http\Requests\FileFunctions\CreateFolderRequest;
+use App\Http\Requests\FileFunctions\DeleteItemRequest;
+use App\Http\Requests\FileFunctions\RenameItemRequest;
+use App\Http\Requests\FileFunctions\MoveItemRequest;
+use App\Http\Requests\FileFunctions\UploadRequest;
+use App\Http\Tools\Demo;
+use Illuminate\Contracts\Routing\ResponseFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use App\Http\Controllers\Controller;
+use App\Http\Tools\Guardian;
+use App\Http\Tools\Editor;
+use App\Models\Folder;
+use App\Models\File;
+use Exception;
+
+
+class EditItemsController extends Controller
+{
+    /**
+     * Create new folder for authenticated master|editor user
+     *
+     * @param CreateFolderRequest $request
+     * @return array
+     * @throws Exception
+     */
+    public function user_create_folder(CreateFolderRequest $request)
+    {
+        // Demo preview
+        if (is_demo(Auth::id())) {
+            return Demo::create_folder($request);
+        }
+
+        // Check permission to create folder for authenticated editor
+        if ($request->user()->tokenCan('editor')) {
+
+            // check if shared_token cookie exist
+            if (!$request->hasCookie('shared_token')) abort('401');
+
+            // Get shared token
+            $shared = get_shared($request->cookie('shared_token'));
+
+            // Check access to requested directory
+            Guardian::check_item_access($request->parent_id, $shared);
+        }
+
+        // Create new folder
+        return Editor::create_folder($request);
+    }
+
+    /**
+     * Create new folder for guest user with edit permission
+     *
+     * @param CreateFolderRequest $request
+     * @param $token
+     * @return array
+     * @throws Exception
+     */
+    public function guest_create_folder(CreateFolderRequest $request, $token)
+    {
+        // Get shared record
+        $shared = get_shared($token);
+
+        if (is_demo($shared->user_id)) {
+            return Demo::create_folder($request);
+        }
+
+        // Check shared permission
+        if (!is_editor($shared)) abort(403);
+
+        // Check access to requested directory
+        Guardian::check_item_access($request->parent_id, $shared);
+
+        // Create folder
+        return Editor::create_folder($request, $shared);
+    }
+
+    /**
+     * Rename item for authenticated master|editor user
+     *
+     * @param RenameItemRequest $request
+     * @param $id
+     * @return mixed
+     * @throws Exception
+     */
+    public function user_rename_item(RenameItemRequest $request, $id)
+    {
+        // Demo preview
+        if (is_demo(Auth::id())) {
+            return Demo::rename_item($request, $id);
+        }
+
+        // Check permission to rename item for authenticated editor
+        if ($request->user()->tokenCan('editor')) {
+
+            // check if shared_token cookie exist
+            if (!$request->hasCookie('shared_token')) abort('401');
+
+            // Get shared token
+            $shared = get_shared($request->cookie('shared_token'));
+
+            // Get file|folder item
+            $item = get_item($request->type, $id);
+
+            // Check access to requested directory
+            if ($request->type === 'folder') {
+                Guardian::check_item_access($item->id, $shared);
+            } else {
+                Guardian::check_item_access($item->folder_id, $shared);
+            }
+        }
+
+        // If request have a change folder icon values set the folder icon
+        if ($request->type === 'folder' && ($request->filled('emoji') || $request->filled('color'))) {
+            Editor::set_folder_icon($request, $id);
+        }
+
+        // Rename Item
+        return Editor::rename_item($request, $id);
+    }
+
+    /**
+     * Rename item for guest user with edit permission
+     *
+     * @param RenameItemRequest $request
+     * @param $id
+     * @param $token
+     * @return mixed
+     * @throws Exception
+     */
+    public function guest_rename_item(RenameItemRequest $request, $id, $token)
+    {
+        // Get shared record
+        $shared = get_shared($token);
+
+        // Demo preview
+        if (is_demo($shared->user_id)) {
+            return Demo::rename_item($request, $id);
+        }
+
+        // Check shared permission
+        if (is_visitor($shared)) {
+            abort(403);
+        }
+
+        // Get file|folder item
+        $item = get_item($request->type, $id);
+
+        // Check access to requested item
+        if ($request->type === 'folder') {
+            Guardian::check_item_access($item->id, $shared);
+        } else {
+            Guardian::check_item_access($item->folder_id, $shared);
+        }
+
+        // If request have a change folder icon values set the folder icon
+        if ($request->type === 'folder' && $request->filled('icon')) {
+            Editor::set_folder_icon($request, $id);
+        }
+
+        // Rename item
+        $item = Editor::rename_item($request, $id, $shared);
+
+        // Set public url
+        if ($item->type !== 'folder') {
+            $item->setPublicUrl($token);
+        }
+
+        return $item;
+    }
+
+    /**
+     * Delete item for authenticated master|editor user
+     *
+     * @param DeleteItemRequest $request
+     * @param $id
+     * @return ResponseFactory|\Illuminate\Http\Response
+     * @throws Exception
+     */
+    public function user_delete_item(DeleteItemRequest $request)
+    {
+        // Demo preview
+        if (is_demo(Auth::id())) {
+            return Demo::response_204();
+        }
+
+        foreach ($request->input('items') as $item) {
+
+            // Check permission to delete item for authenticated editor 
+            if ($request->user()->tokenCan('editor')) {
+
+                // Prevent force delete for non-master users
+                if ($item['force_delete']) abort('401');
+
+                // check if shared_token cookie exist
+                if (!$request->hasCookie('shared_token')) abort('401');
+
+                // Get shared token
+                $shared = get_shared($request->cookie('shared_token'));
+
+                // Get file|folder item
+                $item = get_item($item['type'], $item['id']);
+
+                // Check access to requested directory
+                if ($item['type'] === 'folder') {
+                    Guardian::check_item_access($item->id, $shared);
+                } else {
+                    Guardian::check_item_access($item->folder_id, $shared);
+                }
+            }
+
+            // Delete item
+            Editor::delete_item($item, $item['id']);
+        }
+
+        return response(null, 204);
+    }
+
+    /**
+     * Delete item for guest user with edit permission
+     *
+     * @param DeleteItemRequest $request
+     * @param $id
+     * @param $token
+     * @return ResponseFactory|\Illuminate\Http\Response
+     * @throws Exception
+     */
+    public function guest_delete_item(DeleteItemRequest $request, $token)
+    {
+        // Get shared record
+        $shared = get_shared($token);
+
+        // Demo preview
+        if (is_demo($shared->user_id)) {
+            return Demo::response_204();
+        }
+
+        // Check shared permission
+        if (is_visitor($shared)) {
+            abort(403);
+        }
+
+        foreach ($request->items as $file) {
+
+            // Get file|folder item
+            $item = get_item($file['type'], $file['id']);
+
+            // Check access to requested item
+            if ($file['type'] === 'folder') {
+                Guardian::check_item_access($item->id, $shared);
+            } else {
+                Guardian::check_item_access($item->folder_id, $shared);
+            }
+
+            // Delete item
+            Editor::delete_item($file, $file['id'], $shared);
+        }
+        // Return response
+        return response('Done', 204);
+    }
+
+    /**
+     * Upload file for authenticated master|editor user
+     *
+     * @param UploadRequest $request
+     * @return File|Model
+     * @throws Exception
+     */
+    public function user_upload(UploadRequest $request)
+    {
+        // Demo preview
+        if (is_demo(Auth::id())) {
+            return Demo::upload($request);
+        }
+
+        // Check permission to upload for authenticated editor
+        if ($request->user()->tokenCan('editor')) {
+
+            // check if shared_token cookie exist
+            if (!$request->hasCookie('shared_token')) abort('401');
+
+            // Get shared token
+            $shared = get_shared($request->cookie('shared_token'));
+
+            // Check access to requested directory
+            Guardian::check_item_access($request->parent_id, $shared);
+        }
+
+        // Return new uploaded file
+        return Editor::upload($request);
+    }
+
+    /**
+     * Delete file for guest user with edit permission
+     *
+     * @param UploadRequest $request
+     * @param $token
+     * @return File|Model
+     * @throws Exception
+     */
+    public function guest_upload(UploadRequest $request, $token)
+    {
+        // Get shared record
+        $shared = get_shared($token);
+
+        // Demo preview
+        if (is_demo($shared->user_id)) {
+            return Demo::upload($request);
+        }
+
+        // Check shared permission
+        if (is_visitor($shared)) {
+            abort(403);
+        }
+
+        // Check access to requested directory
+        Guardian::check_item_access($request->folder_id, $shared);
+
+        // Return new uploaded file
+        $new_file = Editor::upload($request, $shared);
+
+        // Set public access url
+        $new_file->setPublicUrl($token);
+
+        return $new_file;
+    }
+
+
+    /**
+     * User download folder via zip
+     *
+     * @param $id
+     * @return string
+     */
+    public function user_zip_folder(Request $request, $id)
+    {
+        // Get user id
+        $user_id = Auth::id();
+
+        // Check permission to download for authenticated editor
+        if ($request->user()->tokenCan('editor')) {
+
+            // check if shared_token cookie exist
+            if (!$request->hasCookie('shared_token')) abort('401');
+
+            // Get shared token
+            $shared = get_shared($request->cookie('shared_token'));
+
+            // Check access to requested directory
+            Guardian::check_item_access($id, $shared);
+        }
+
+        // Get folder
+        $folder = Folder::whereUserId($user_id)
+            ->where('id', $id);
+
+        if (!$folder->exists()) {
+            abort(404, 'Requested folder doesn\'t exists.');
+        }
+
+        $zip = Editor::zip_folder($id);
+
+        // Get file
+        return response([
+            'url'  => route('zip', $zip->id),
+            'name' => $zip->basename,
+        ], 201);
+    }
+
+    /**
+     * Guest download folder via zip
+     *
+     * @param Request $request
+     * @param $id
+     * @param $token
+     * @return string
+     */
+    public function guest_zip_folder($id, $token)
+    {
+        // Get shared record
+        $shared = get_shared($token);
+
+        // Check access to requested folder
+        Guardian::check_item_access($id, $shared);
+
+        // Get folder
+        $folder = Folder::whereUserId($shared->user_id)
+            ->where('id', $id);
+
+        if (!$folder->exists()) {
+            abort(404, 'Requested folder doesn\'t exists.');
+        }
+
+        $zip = Editor::zip_folder($id, $shared);
+
+        // Get file
+        return response([
+            'url'  => route('zip_public', [
+                'id'    => $zip->id,
+                'token' => $shared->token,
+            ]),
+            'name' => $zip->basename,
+        ], 201);
+    }
+
+    /**
+     * User download multiple files via zip
+     *
+     * @param Request $request
+     * @return string
+     */
+    public function user_zip_multiple_files(Request $request)
+    {
+        // Check permission to upload for authenticated editor
+        if ($request->user()->tokenCan('editor')) {
+
+            // check if shared_token cookie exist
+            if (!$request->hasCookie('shared_token')) abort('401');
+
+            // Get shared token
+            $shared = get_shared($request->cookie('shared_token'));
+
+            $file_parent_folders = File::whereUserId(Auth::id())
+                ->whereIn('id', $request->input('files'))
+                ->get()
+                ->pluck('folder_id')
+                ->toArray();
+
+            // Check access to requested directory
+            Guardian::check_item_access($file_parent_folders, $shared);
+        }
+
+        // Get requested files
+        $files = File::whereUserId(Auth::id())
+            ->whereIn('id', $request->input('items'))
+            ->get();
+
+        $zip = Editor::zip_files($files);
+
+        // Get file
+        return response([
+            'url'  => route('zip', $zip->id),
+            'name' => $zip->basename,
+        ], 201);
+    }
+
+    /**
+     * Guest download multiple files via zip
+     *
+     * @param Request $request
+     * @param $token
+     * @return string
+     */
+    public function guest_zip_multiple_files(Request $request, $token)
+    {
+        // Get shared record
+        $shared = get_shared($token);
+
+        $file_parent_folders = File::whereUserId($shared->user_id)
+            ->whereIn('id', $request->items)
+            ->get()
+            ->pluck('folder_id')
+            ->toArray();
+
+        // Check access to requested directory
+        Guardian::check_item_access($file_parent_folders, $shared);
+
+        // Get requested files
+        $files = File::whereUserId($shared->user_id)
+            ->whereIn('id', $request->items)
+            ->get();
+
+        $zip = Editor::zip_files($files, $shared);
+
+        // Get file
+        return response([
+            'url'  => route('zip_public', [
+                'id'    => $zip->id,
+                'token' => $shared->token,
+            ]),
+            'name' => $zip->basename,
+        ], 201);
+    }
+
+    /**
+     * Move item for authenticated master|editor user
+     *
+     * @param MoveItemRequest $request
+     * @param $id
+     * @return ResponseFactory|\Illuminate\Http\Response
+     */
+    public function user_move(MoveItemRequest $request)
+    {
+        // Demo preview
+        if (is_demo(Auth::id())) {
+            return Demo::response_204();
+        }
+
+        $to_id = $request->input('to_id');
+
+        // Check permission to upload for authenticated editor
+        if ($request->user()->tokenCan('editor')) {
+
+            // check if shared_token cookie exist
+            if (!$request->hasCookie('shared_token')) abort('401');
+
+            // Get shared token
+            $shared = get_shared($request->cookie('shared_token'));
+
+            // Check access to requested directory
+            Guardian::check_item_access($to_id, $shared);
+        }
+
+        // Move item
+        Editor::move($request, $to_id);
+
+        return response('Done!', 204);
+    }
+
+    /**
+     * Move item for guest user with edit permission
+     *
+     * @param MoveItemRequest $request
+     * @param $id
+     * @param $token
+     * @return ResponseFactory|\Illuminate\Http\Response
+     */
+    public function guest_move(MoveItemRequest $request, $token)
+    {
+        // Get shared record
+        $shared = get_shared($token);
+
+        // Demo preview
+        if (is_demo(Auth::id())) {
+            return Demo::response_204();
+        }
+
+        // Check shared permission
+        if (is_visitor($shared)) {
+            abort(403);
+        }
+
+        foreach ($request->items as $item) {
+
+            if ($item['type'] === 'folder') {
+
+                Guardian::check_item_access([
+                    $request->to_id, $item['id']
+                ], $shared);
+            }
+
+            if ($item['type'] !== 'folder') {
+
+                $file = File::where('id', $item['id'])
+                    ->where('user_id', $shared->user_id)
+                    ->firstOrFail();
+
+                Guardian::check_item_access([
+                    $request->to_id, $file->folder_id
+                ], $shared);
+            }
+        }
+
+        Editor::move($request, $request->to_id);
+
+        return response('Done!', 204);
+    }
+}

app/Http/Controllers/FileManager/FavouriteController.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Http\Controllers\FileManager;
+
+use App\Http\Tools\Demo;
+use App\Models\Folder;
+use Illuminate\Support\Facades\Validator;
+use App\Http\Controllers\Controller;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Http\Request;
+
+class FavouriteController extends Controller
+{
+    /**
+     * Add folder to user favourites
+     *
+     * @param Request $request
+     * @return \Illuminate\Contracts\Routing\ResponseFactory|\Illuminate\Http\Response
+     */
+    public function store(Request $request)
+    {
+        // todo: pridat validator ako AddToFavouritesRequest
+
+        foreach ($request->folders as $id) {
+
+            // Get user & folder
+            $user = Auth::user();
+
+            if (is_demo($user->id)) {
+                return Demo::favourites($user);
+            }
+
+            // Add folder to user favourites
+            $user
+                ->favouriteFolders()
+                ->syncWithoutDetaching($id);
+        }
+
+        // Return updated favourites
+        return response($user->favouriteFolders, 204);
+    }
+
+    /**
+     * Remove folder from user favourites
+     *
+     * @param $id
+     * @return \Illuminate\Contracts\Routing\ResponseFactory|\Illuminate\Http\Response
+     */
+    public function destroy($id)
+    {
+        // Get user
+        $user = Auth::user();
+
+        if (is_demo($user->id)) {
+            return Demo::favourites($user);
+        }
+
+        // Remove folder from user favourites
+        $user->favouriteFolders()->detach($id);
+
+        // Return updated favourites
+        return response($user->favouriteFolders, 204);
+    }
+}

app/Http/Controllers/FileManager/ShareController.php

@@ -0,0 +1,167 @@
+<?php
+
+namespace App\Http\Controllers\FileManager;
+
+use App\Http\Requests\Share\CreateShareRequest;
+use App\Http\Requests\Share\UpdateShareRequest;
+use App\Http\Resources\ShareResource;
+use App\Models\Share;
+use App\Models\Zip;
+use App\Notifications\SharedSendViaEmail;
+use Illuminate\Contracts\Routing\ResponseFactory;
+use App\Http\Controllers\Controller;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Notification;
+use Illuminate\Support\Str;
+use Validator;
+
+class ShareController extends Controller
+{
+    /**
+     * Get shared record
+     *
+     * @return ShareResource
+     */
+    public function show($token)
+    {
+        // Get record
+        $shared = Share::whereToken($token)
+            ->firstOrFail();
+
+        return new ShareResource($shared);
+    }
+
+    /**
+     * Generate file share link
+     *
+     * @param CreateShareRequest $request
+     * @param $id
+     * @return ShareResource
+     */
+    public function store(CreateShareRequest $request, $id)
+    {
+        // TODO: poriesit binarny string
+        do {
+            // Generate unique token
+            $token = Str::random(16);
+
+        } while (Share::where('token', $token)->exists());
+
+        // Create shared options
+        $options = [
+            'password'     => $request->has('password') ? Hash::make($request->password) : null,
+            'type'         => $request->type === 'folder' ? 'folder' : 'file',
+            'is_protected' => $request->isPassword,
+            'permission'   => $request->permission ?? null,
+            'item_id'      => $id,
+            'expire_in'    => $request->expiration ?? null,
+            'user_id'      => Auth::id(),
+            'token'        => $token,
+        ];
+
+        // Send shared link via email
+        if ($request->has('emails')) {
+
+            foreach ($request->emails as $email) {
+
+                Notification::route('mail', $email)->notify(
+                    new SharedSendViaEmail($token)
+                );
+            }
+        }
+
+        // Return created shared record
+        return new ShareResource(Share::create($options));
+    }
+
+    /**
+     * Update sharing
+     *
+     * @param UpdateShareRequest $request
+     * @param $token
+     * @return ShareResource
+     */
+    public function update(UpdateShareRequest $request, $token)
+    {
+        // Get sharing record
+        $shared = Share::where('token', $token)
+            ->where('user_id', Auth::id())
+            ->firstOrFail();
+
+        // Update sharing record
+        $shared->update([
+            'permission'   => $request->permission,
+            'is_protected' => $request->protected,
+            'expire_in'    => $request->expiration,
+            'password'     => $request->password ? Hash::make($request->password) : $shared->password,
+        ]);
+
+        // Return shared record
+        return new ShareResource($shared);
+    }
+
+    /**
+     * Delete sharing item
+     *
+     * @param $token
+     * @return ResponseFactory|\Illuminate\Http\Response
+     * @throws \Exception
+     */
+    public function destroy(Request $request)
+    {
+        foreach ($request->tokens as $token) {
+
+            // Get sharing record
+            Share::where('token', $token)
+                ->where('user_id', Auth::id())
+                ->firstOrFail()
+                ->delete();
+
+            // Get zip record
+            $zip = Zip::where('shared_token', $token)
+                ->where('user_id', Auth::id())
+                ->first();
+
+            if ($zip) {
+                $zip->delete();
+            }
+        }
+
+        // Done
+        return response('Done!', 204);
+    }
+
+    /**
+     * Send shared link via email to recipients
+     *
+     * @param $token
+     * @param $request
+     */
+    public function send_to_emails_recipients(Request $request, $token)
+    {
+        // TODO: pridat validation request
+        // Make validation of array of emails
+        $validator = Validator::make($request->all(), [
+            'emails.*' => 'required|email',
+        ]);
+
+        // Return error
+        if ($validator->fails()) {
+            abort(400, 'Bad email input');
+        }
+
+        // Send shared link via email
+        if ($request->has('emails')) {
+
+            foreach ($request->emails as $email) {
+                Notification::route('mail', $email)
+                    ->notify(new SharedSendViaEmail($token));
+            }
+        }
+
+        return response('Done!', 204);
+    }
+}

app/Http/Controllers/FileManager/TrashController.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace App\Http\Controllers\FileManager;
+
+use App\Http\Tools\Demo;
+use Illuminate\Contracts\Routing\ResponseFactory;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Support\Facades\Storage;
+use App\Http\Controllers\Controller;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Http\Request;
+use App\Models\Folder;
+use App\Models\File;
+
+class TrashController extends Controller
+{
+    /**
+     * Restore item from trash
+     *
+     * @param Request $request
+     * @return ResponseFactory|\Illuminate\Http\Response
+     */
+    public function restore(Request $request)
+    {
+        // Validate request
+        // TODO: zrefaktorovat validator do requestu
+        $validator = Validator::make($request->input('items'), [
+            '*.type' => 'required|string',
+            '*.id'   => 'string',
+        ]);
+
+        // Return error
+        if ($validator->fails()) abort(400, 'Bad input');
+
+        // Get user id
+        $user_id = Auth::id();
+
+        if (is_demo($user_id)) {
+            return Demo::response_204();
+        }
+
+        foreach ($request->input('items') as $restore) {
+
+            // Get folder
+            if ($restore['type'] === 'folder') {
+
+                // Get folder
+                $item = Folder::onlyTrashed()
+                    ->where('user_id', $user_id)
+                    ->where('id', $restore['id'])
+                    ->first();
+
+                // Restore item to home directory
+                if ($request->has('to_home') && $request->to_home) {
+                    $item->parent_id = null;
+                    $item->save();
+                }
+            } else {
+
+                // Get item
+                $item = File::onlyTrashed()
+                    ->where('user_id', $user_id)
+                    ->where('id', $restore['id'])
+                    ->first();
+
+                // Restore item to home directory
+                if ($request->has('to_home') && $request->to_home) {
+                    $item->folder_id = null;
+                    $item->save();
+                }
+            }
+
+            // Restore Item
+            $item->restore();
+        }
+
+        // Return response
+        return response('Done!', 204);
+    }
+
+    /**
+     * Empty user trash
+     *
+     * @return ResponseFactory|\Illuminate\Http\Response
+     */
+    public function dump()
+    {
+        // Get user id
+        $user_id = Auth::id();
+
+        if (is_demo($user_id)) {
+            return Demo::response_204();
+        }
+
+        // Get files and folders
+        $folders = Folder::onlyTrashed()->where('user_id', $user_id)->get();
+        $files = File::onlyTrashed()->where('user_id', $user_id)->get();
+
+        // Force delete folder
+        $folders->each->forceDelete();
+
+        // Force delete files
+        foreach ($files as $file) {
+
+            // Delete file
+            Storage::delete("/files/$user_id/{$file->basename}");
+
+            // Delete thumbnail if exist
+            if ($file->thumbnail) {
+                Storage::delete("/files/$user_id/{$file->getRawOriginal('thumbnail')}");
+            }
+
+            // Delete file permanently
+            $file->forceDelete();
+        }
+
+        // Return response
+        return response('Done!', 204);
+    }
+}