|
1
|
|
|
<?php |
|
2
|
|
|
|
|
3
|
|
|
namespace Backpack\CRUD; |
|
4
|
|
|
|
|
5
|
|
|
use DB; |
|
6
|
|
|
use Illuminate\Database\Eloquent\Model; |
|
7
|
|
|
use Illuminate\Support\Facades\Config; |
|
8
|
|
|
|
|
9
|
|
|
trait CrudTrait |
|
10
|
|
|
{ |
|
11
|
|
|
/* |
|
12
|
|
|
|-------------------------------------------------------------------------- |
|
13
|
|
|
| Methods for ENUM and SELECT crud fields. |
|
14
|
|
|
|-------------------------------------------------------------------------- |
|
15
|
|
|
*/ |
|
16
|
|
|
|
|
17
|
|
|
public static function getPossibleEnumValues($field_name) |
|
|
|
|
|
|
18
|
|
|
{ |
|
19
|
|
|
$instance = new static(); // create an instance of the model to be able to get the table name |
|
20
|
|
|
$type = DB::select(DB::raw('SHOW COLUMNS FROM '.Config::get('database.connections.'.env('DB_CONNECTION').'.prefix').$instance->getTable().' WHERE Field = "'.$field_name.'"'))[0]->Type; |
|
|
|
|
|
|
21
|
|
|
preg_match('/^enum\((.*)\)$/', $type, $matches); |
|
22
|
|
|
$enum = []; |
|
23
|
|
|
foreach (explode(',', $matches[1]) as $value) { |
|
24
|
|
|
$enum[] = trim($value, "'"); |
|
25
|
|
|
} |
|
26
|
|
|
|
|
27
|
|
|
return $enum; |
|
28
|
|
|
} |
|
29
|
|
|
|
|
30
|
|
|
public static function isColumnNullable($column_name) |
|
|
|
|
|
|
31
|
|
|
{ |
|
32
|
|
|
// create an instance of the model to be able to get the table name |
|
33
|
|
|
$instance = new static(); |
|
34
|
|
|
|
|
35
|
|
|
// register the enum column type, because Doctrine doesn't support it |
|
36
|
|
|
DB::connection()->getDoctrineSchemaManager()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); |
|
|
|
|
|
|
37
|
|
|
|
|
38
|
|
|
return ! DB::connection()->getDoctrineColumn($instance->getTable(), $column_name)->getNotnull(); |
|
|
|
|
|
|
39
|
|
|
} |
|
40
|
|
|
|
|
41
|
|
|
/* |
|
42
|
|
|
|-------------------------------------------------------------------------- |
|
43
|
|
|
| Methods for Fake Fields functionality (used in PageManager). |
|
44
|
|
|
|-------------------------------------------------------------------------- |
|
45
|
|
|
*/ |
|
46
|
|
|
|
|
47
|
|
|
/** |
|
48
|
|
|
* Add fake fields as regular attributes, even though they are stored as JSON. |
|
49
|
|
|
* |
|
50
|
|
|
* @param array $columns - the database columns that contain the JSONs |
|
51
|
|
|
*/ |
|
52
|
|
|
public function addFakes($columns = ['extras']) |
|
53
|
|
|
{ |
|
54
|
|
|
foreach ($columns as $key => $column) { |
|
55
|
|
|
$column_contents = $this->{$column}; |
|
56
|
|
|
|
|
57
|
|
|
if (! is_object($this->{$column})) { |
|
58
|
|
|
$column_contents = json_decode($this->{$column}); |
|
59
|
|
|
} |
|
60
|
|
|
|
|
61
|
|
|
if (count($column_contents)) { |
|
62
|
|
|
foreach ($column_contents as $fake_field_name => $fake_field_value) { |
|
63
|
|
|
$this->setAttribute($fake_field_name, $fake_field_value); |
|
|
|
|
|
|
64
|
|
|
} |
|
65
|
|
|
} |
|
66
|
|
|
} |
|
67
|
|
|
} |
|
68
|
|
|
|
|
69
|
|
|
/** |
|
70
|
|
|
* Return the entity with fake fields as attributes. |
|
71
|
|
|
* |
|
72
|
|
|
* @param array $columns - the database columns that contain the JSONs |
|
73
|
|
|
* |
|
74
|
|
|
* @return Model |
|
|
|
|
|
|
75
|
|
|
*/ |
|
76
|
|
|
public function withFakes($columns = []) |
|
77
|
|
|
{ |
|
78
|
|
|
$model = '\\'.get_class($this); |
|
79
|
|
|
|
|
80
|
|
|
if (! count($columns)) { |
|
81
|
|
|
$columns = (property_exists($model, 'fakeColumns')) ? $this->fakeColumns : ['extras']; |
|
|
|
|
|
|
82
|
|
|
} |
|
83
|
|
|
|
|
84
|
|
|
$this->addFakes($columns); |
|
85
|
|
|
|
|
86
|
|
|
return $this; |
|
87
|
|
|
} |
|
88
|
|
|
|
|
89
|
|
|
/* |
|
90
|
|
|
|-------------------------------------------------------------------------- |
|
91
|
|
|
| Methods for storing uploaded files (used in CRUD). |
|
92
|
|
|
|-------------------------------------------------------------------------- |
|
93
|
|
|
*/ |
|
94
|
|
|
|
|
95
|
|
|
/** |
|
96
|
|
|
* Handle file upload and DB storage for a file: |
|
97
|
|
|
* - on CREATE |
|
98
|
|
|
* - stores the file at the destination path |
|
99
|
|
|
* - generates a name |
|
100
|
|
|
* - stores the full path in the DB; |
|
101
|
|
|
* - on UPDATE |
|
102
|
|
|
* - if the value is null, deletes the file and sets null in the DB |
|
103
|
|
|
* - if the value is different, stores the different file and updates DB value. |
|
104
|
|
|
* |
|
105
|
|
|
* @param [type] $value Value for that column sent from the input. |
|
|
|
|
|
|
106
|
|
|
* @param [type] $attribute_name Model attribute name (and column in the db). |
|
|
|
|
|
|
107
|
|
|
* @param [type] $disk Filesystem disk used to store files. |
|
|
|
|
|
|
108
|
|
|
* @param [type] $destination_path Path in disk where to store the files. |
|
|
|
|
|
|
109
|
|
|
*/ |
|
110
|
|
|
public function uploadFileToDisk($value, $attribute_name, $disk, $destination_path) |
|
|
|
|
|
|
111
|
|
|
{ |
|
112
|
|
|
$request = \Request::instance(); |
|
113
|
|
|
|
|
114
|
|
|
// if a new file is uploaded, delete the file from the disk |
|
115
|
|
|
if ($request->hasFile($attribute_name) && |
|
116
|
|
|
$this->{$attribute_name} && |
|
117
|
|
|
$this->{$attribute_name} != null) { |
|
118
|
|
|
\Storage::disk($disk)->delete($this->{$attribute_name}); |
|
119
|
|
|
$this->attributes[$attribute_name] = null; |
|
|
|
|
|
|
120
|
|
|
} |
|
121
|
|
|
|
|
122
|
|
|
// if the file input is empty, delete the file from the disk |
|
123
|
|
|
if (is_null($value) && $this->{$attribute_name} != null) { |
|
124
|
|
|
\Storage::disk($disk)->delete($this->{$attribute_name}); |
|
125
|
|
|
$this->attributes[$attribute_name] = null; |
|
126
|
|
|
} |
|
127
|
|
|
|
|
128
|
|
|
// if a new file is uploaded, store it on disk and its filename in the database |
|
129
|
|
View Code Duplication |
if ($request->hasFile($attribute_name) && $request->file($attribute_name)->isValid()) { |
|
|
|
|
|
|
130
|
|
|
|
|
131
|
|
|
// 1. Generate a new file name |
|
132
|
|
|
$file = $request->file($attribute_name); |
|
133
|
|
|
$new_file_name = md5($file->getClientOriginalName().time()).'.'.$file->getClientOriginalExtension(); |
|
134
|
|
|
|
|
135
|
|
|
// 2. Move the new file to the correct path |
|
136
|
|
|
$file_path = $file->storeAs($destination_path, $new_file_name, $disk); |
|
137
|
|
|
|
|
138
|
|
|
// 3. Save the complete path to the database |
|
139
|
|
|
$this->attributes[$attribute_name] = $file_path; |
|
140
|
|
|
} |
|
141
|
|
|
} |
|
142
|
|
|
|
|
143
|
|
|
/** |
|
144
|
|
|
* Handle multiple file upload and DB storage: |
|
145
|
|
|
* - if files are sent |
|
146
|
|
|
* - stores the files at the destination path |
|
147
|
|
|
* - generates random names |
|
148
|
|
|
* - stores the full path in the DB, as JSON array; |
|
149
|
|
|
* - if a hidden input is sent to clear one or more files |
|
150
|
|
|
* - deletes the file |
|
151
|
|
|
* - removes that file from the DB. |
|
152
|
|
|
* |
|
153
|
|
|
* @param [type] $value Value for that column sent from the input. |
|
|
|
|
|
|
154
|
|
|
* @param [type] $attribute_name Model attribute name (and column in the db). |
|
|
|
|
|
|
155
|
|
|
* @param [type] $disk Filesystem disk used to store files. |
|
|
|
|
|
|
156
|
|
|
* @param [type] $destination_path Path in disk where to store the files. |
|
|
|
|
|
|
157
|
|
|
*/ |
|
158
|
|
|
public function uploadMultipleFilesToDisk($value, $attribute_name, $disk, $destination_path) |
|
|
|
|
|
|
159
|
|
|
{ |
|
160
|
|
|
$request = \Request::instance(); |
|
161
|
|
|
$attribute_value = (array) $this->{$attribute_name}; |
|
162
|
|
|
$files_to_clear = $request->get('clear_'.$attribute_name); |
|
163
|
|
|
|
|
164
|
|
|
// if a file has been marked for removal, |
|
165
|
|
|
// delete it from the disk and from the db |
|
166
|
|
|
if ($files_to_clear) { |
|
167
|
|
|
$attribute_value = (array) $this->{$attribute_name}; |
|
168
|
|
|
foreach ($files_to_clear as $key => $filename) { |
|
169
|
|
|
\Storage::disk($disk)->delete($filename); |
|
170
|
|
|
$attribute_value = array_where($attribute_value, function ($value, $key) use ($filename) { |
|
|
|
|
|
|
171
|
|
|
return $value != $filename; |
|
172
|
|
|
}); |
|
173
|
|
|
} |
|
174
|
|
|
} |
|
175
|
|
|
|
|
176
|
|
|
// if a new file is uploaded, store it on disk and its filename in the database |
|
177
|
|
View Code Duplication |
if ($request->hasFile($attribute_name)) { |
|
|
|
|
|
|
178
|
|
|
foreach ($request->file($attribute_name) as $file) { |
|
|
|
|
|
|
179
|
|
|
if ($file->isValid()) { |
|
180
|
|
|
// 1. Generate a new file name |
|
181
|
|
|
$new_file_name = md5($file->getClientOriginalName().time()).'.'.$file->getClientOriginalExtension(); |
|
182
|
|
|
|
|
183
|
|
|
// 2. Move the new file to the correct path |
|
184
|
|
|
$file_path = $file->storeAs($destination_path, $new_file_name, $disk); |
|
185
|
|
|
|
|
186
|
|
|
// 3. Add the public path to the database |
|
187
|
|
|
$attribute_value[] = $file_path; |
|
188
|
|
|
} |
|
189
|
|
|
} |
|
190
|
|
|
} |
|
191
|
|
|
|
|
192
|
|
|
$this->attributes[$attribute_name] = json_encode($attribute_value); |
|
193
|
|
|
} |
|
194
|
|
|
|
|
195
|
|
|
/** |
|
196
|
|
|
* Handle image upload and DB storage for a image: |
|
197
|
|
|
* - on CREATE |
|
198
|
|
|
* - stores the image at the destination path |
|
199
|
|
|
* - generates a name |
|
200
|
|
|
* - creates image variations |
|
201
|
|
|
* - stores json object into database with variations and paths |
|
202
|
|
|
* - on UPDATE |
|
203
|
|
|
* - if the value is null, deletes the file and sets null in the DB |
|
204
|
|
|
* - if the value is different, stores the different file and updates DB value. |
|
205
|
|
|
* |
|
206
|
|
|
* @param [type] $value Value for that column sent from the input. |
|
|
|
|
|
|
207
|
|
|
* @param [type] $attribute_name Model attribute name (and column in the db). |
|
|
|
|
|
|
208
|
|
|
* @param [type] $disk Filesystem disk used to store files. |
|
|
|
|
|
|
209
|
|
|
* @param [type] $destination_path Path in disk where to store the files. |
|
|
|
|
|
|
210
|
|
|
* @param [type] $variations Array of variations and their dimensions |
|
|
|
|
|
|
211
|
|
|
*/ |
|
212
|
|
|
public function uploadImageToDisk($value, $attribute_name, $disk, $destination_path, $variations = null) |
|
|
|
|
|
|
213
|
|
|
{ |
|
214
|
|
|
if (! $variations || ! is_array($variations)) { |
|
215
|
|
|
$variations = ['original' => null, 'thumb' => [150, 150]]; |
|
216
|
|
|
} |
|
217
|
|
|
|
|
218
|
|
|
//Needed for the original image |
|
219
|
|
|
if (! array_key_exists('original', $variations)) { |
|
220
|
|
|
$variations['original'] = null; |
|
221
|
|
|
} |
|
222
|
|
|
|
|
223
|
|
|
//Needed for admin thumbnails |
|
224
|
|
|
if (! array_key_exists('thumb', $variations)) { |
|
225
|
|
|
$variations['thumb'] = [150, 150]; |
|
226
|
|
|
} |
|
227
|
|
|
|
|
228
|
|
|
$request = \Request::instance(); |
|
229
|
|
|
|
|
230
|
|
|
//We need to setup the disk paths as they're handled differently |
|
231
|
|
|
//depending if you need a public path or internal storage |
|
232
|
|
|
$disk_config = config('filesystems.disks.'.$disk); |
|
233
|
|
|
$disk_root = $disk_config['root']; |
|
234
|
|
|
|
|
235
|
|
|
//if the disk is public, we need to know the public path |
|
236
|
|
View Code Duplication |
if ($disk_config['visibility'] == 'public') { |
|
|
|
|
|
|
237
|
|
|
$public_path = str_replace(public_path(), '', $disk_root); |
|
238
|
|
|
} else { |
|
239
|
|
|
$public_path = $disk_root; |
|
240
|
|
|
} |
|
241
|
|
|
|
|
242
|
|
|
// if a new file is uploaded, delete the file from the disk |
|
243
|
|
|
if (($request->hasFile($attribute_name) || starts_with($value, 'data:image')) && $this->{$attribute_name}) { |
|
244
|
|
View Code Duplication |
foreach ($variations as $variant => $dimensions) { |
|
|
|
|
|
|
245
|
|
|
$variant_name = str_replace('-original', '-'.$variant, $this->{$attribute_name}); |
|
246
|
|
|
\Storage::disk($disk)->delete($variant_name); |
|
247
|
|
|
} |
|
248
|
|
|
$this->attributes[$attribute_name] = null; |
|
249
|
|
|
} |
|
250
|
|
|
|
|
251
|
|
|
// if the file input is empty, delete the file from the disk |
|
252
|
|
|
if (empty($value)) { |
|
253
|
|
View Code Duplication |
foreach ($variations as $variant => $dimensions) { |
|
|
|
|
|
|
254
|
|
|
$variant_name = str_replace('-original', '-'.$variant, $this->{$attribute_name}); |
|
255
|
|
|
\Storage::disk($disk)->delete($variant_name); |
|
256
|
|
|
} |
|
257
|
|
|
|
|
258
|
|
|
return $this->attributes[$attribute_name] = null; |
|
259
|
|
|
} |
|
260
|
|
|
|
|
261
|
|
|
// if a new file is uploaded, store it on disk and its filename in the database |
|
262
|
|
|
if ($request->hasFile($attribute_name) && $request->file($attribute_name)->isValid()) { |
|
263
|
|
|
|
|
264
|
|
|
// 1. Generate a new file name |
|
265
|
|
|
$file = $request->file($attribute_name); |
|
266
|
|
|
$new_file_name = md5($file->getClientOriginalName().time()); |
|
267
|
|
|
$new_file = $new_file_name.'.'.$file->getClientOriginalExtension(); |
|
268
|
|
|
|
|
269
|
|
|
// 2. Move the new file to the correct path |
|
270
|
|
|
$file_path = $file->storeAs($destination_path, $new_file, $disk); |
|
271
|
|
|
$image_variations = []; |
|
272
|
|
|
|
|
273
|
|
|
// 3. but only if they have the ability to crop/handle images |
|
274
|
|
|
if (class_exists('\Intervention\Image\ImageManagerStatic')) { |
|
275
|
|
|
$img = \Intervention\Image\ImageManagerStatic::make($file); |
|
276
|
|
|
foreach ($variations as $variant => $dimensions) { |
|
277
|
|
|
$variant_name = $new_file_name.'-'.$variant.'.'.$file->getClientOriginalExtension(); |
|
278
|
|
|
$variant_file = $destination_path.'/'.$variant_name; |
|
279
|
|
|
|
|
280
|
|
View Code Duplication |
if ($dimensions) { |
|
|
|
|
|
|
281
|
|
|
$width = $dimensions[0]; |
|
282
|
|
|
$height = $dimensions[1]; |
|
283
|
|
|
|
|
284
|
|
|
if ($img->width() > $width || $img->height() > $height) { |
|
285
|
|
|
$img->resize($width, $height, function ($constraint) { |
|
286
|
|
|
$constraint->aspectRatio(); |
|
287
|
|
|
}) |
|
288
|
|
|
->save($disk_root.'/'.$variant_file); |
|
289
|
|
|
} else { |
|
290
|
|
|
$img->save($disk_root.'/'.$variant_file); |
|
291
|
|
|
} |
|
292
|
|
|
|
|
293
|
|
|
$image_variations[$variant] = $public_path.'/'.$variant_file; |
|
294
|
|
|
} else { |
|
295
|
|
|
$image_variations['original'] = $public_path.'/'.$file_path; |
|
296
|
|
|
} |
|
297
|
|
|
} |
|
298
|
|
|
} else { |
|
299
|
|
|
$image_variations['original'] = $public_path.'/'.$file_path; |
|
300
|
|
|
$image_variations['thumb'] = $public_path.'/'.$file_path; |
|
301
|
|
|
} |
|
302
|
|
|
|
|
303
|
|
|
// 3. Save the complete path to the database |
|
304
|
|
|
$this->attributes[$attribute_name] = $image_variations['original']; |
|
305
|
|
|
} elseif (starts_with($value, 'data:image')) { |
|
306
|
|
|
$img = \Intervention\Image\ImageManagerStatic::make($value); |
|
307
|
|
|
$new_file_name = md5($value.time()); |
|
308
|
|
|
|
|
309
|
|
|
if (! \Illuminate\Support\Facades\File::exists($disk_root.'/'.trim($destination_path, '/'))) { |
|
310
|
|
|
\Illuminate\Support\Facades\File::makeDirectory($disk_root.'/'.trim($destination_path, '/'), 0775, true); |
|
|
|
|
|
|
311
|
|
|
} |
|
312
|
|
|
|
|
313
|
|
|
foreach ($variations as $variant => $dimensions) { |
|
314
|
|
|
switch ($img->mime()) { |
|
315
|
|
|
case 'image/bmp': |
|
316
|
|
|
case 'image/ief': |
|
317
|
|
|
case 'image/jpeg': |
|
318
|
|
|
case 'image/pipeg': |
|
319
|
|
|
case 'image/tiff': |
|
320
|
|
|
case 'image/x-jps': |
|
321
|
|
|
$extension = '.jpg'; |
|
322
|
|
|
break; |
|
323
|
|
|
case 'image/gif': |
|
324
|
|
|
$extension = '.gif'; |
|
325
|
|
|
break; |
|
326
|
|
|
case 'image/x-icon': |
|
327
|
|
|
case 'image/png': |
|
328
|
|
|
$extension = '.png'; |
|
329
|
|
|
break; |
|
330
|
|
|
default: |
|
331
|
|
|
$extension = '.jpg'; |
|
332
|
|
|
break; |
|
333
|
|
|
} |
|
334
|
|
|
|
|
335
|
|
|
$variant_name = $new_file_name.'-'.$variant.$extension; |
|
336
|
|
|
$variant_file = $destination_path.'/'.$variant_name; |
|
337
|
|
|
|
|
338
|
|
View Code Duplication |
if ($dimensions) { |
|
|
|
|
|
|
339
|
|
|
$width = $dimensions[0]; |
|
340
|
|
|
$height = $dimensions[1]; |
|
341
|
|
|
|
|
342
|
|
|
if ($img->width() > $width || $img->height() > $height) { |
|
343
|
|
|
$img->resize($width, $height, function ($constraint) { |
|
344
|
|
|
$constraint->aspectRatio(); |
|
345
|
|
|
}) |
|
346
|
|
|
->save($disk_root.'/'.$variant_file); |
|
347
|
|
|
} else { |
|
348
|
|
|
$img->save($disk_root.'/'.$variant_file); |
|
349
|
|
|
} |
|
350
|
|
|
|
|
351
|
|
|
$image_variations[$variant] = $public_path.'/'.$variant_file; |
|
|
|
|
|
|
352
|
|
|
} else { |
|
353
|
|
|
$img->save($disk_root.'/'.$variant_file); |
|
354
|
|
|
$image_variations['original'] = $variant_file; |
|
|
|
|
|
|
355
|
|
|
} |
|
356
|
|
|
} |
|
357
|
|
|
|
|
358
|
|
|
$this->attributes[$attribute_name] = $image_variations['original']; |
|
359
|
|
|
} |
|
360
|
|
|
} |
|
361
|
|
|
|
|
362
|
|
|
/** |
|
363
|
|
|
* Handles the retrieval of an image by variant:. |
|
364
|
|
|
* |
|
365
|
|
|
* @param [type] $attribute Name of the attribute within the model that contains the json |
|
|
|
|
|
|
366
|
|
|
* @param [type] $variant Name of the variant you want to extract |
|
|
|
|
|
|
367
|
|
|
* @param [type] $disk Filesystem disk used to store files. |
|
|
|
|
|
|
368
|
|
|
*/ |
|
369
|
|
|
public function getUploadedImageFromDisk($attribute, $variant = 'original', $disk = null) |
|
|
|
|
|
|
370
|
|
|
{ |
|
371
|
|
|
$image = $this->attributes['image']; |
|
372
|
|
|
$url = null; |
|
373
|
|
|
if (! empty($image)) { |
|
374
|
|
|
$image_variant = str_replace('-original', '-'.$variant, $image); |
|
375
|
|
|
|
|
376
|
|
|
if ($disk) { |
|
377
|
|
|
$disk_config = config('filesystems.disks.'.$disk); |
|
378
|
|
|
$disk_root = $disk_config['root']; |
|
379
|
|
|
|
|
380
|
|
|
//if the disk is public, we need to know the public path |
|
381
|
|
View Code Duplication |
if ($disk_config['visibility'] == 'public') { |
|
|
|
|
|
|
382
|
|
|
$public_path = str_replace(public_path(), '', $disk_root); |
|
383
|
|
|
} else { |
|
384
|
|
|
$public_path = $disk_root; |
|
385
|
|
|
} |
|
386
|
|
|
|
|
387
|
|
|
if (\Storage::disk($disk)->exists($image_variant)) { |
|
388
|
|
|
$url = asset($public_path.'/'.$image_variant); |
|
389
|
|
|
} else { |
|
390
|
|
|
$url = asset($public_path.'/'.trim($image, '/')); |
|
391
|
|
|
} |
|
392
|
|
|
} else { |
|
393
|
|
|
if (\Storage::exists($image_variant)) { |
|
|
|
|
|
|
394
|
|
|
$url = \Storage::url(trim($image_variant, '/')); |
|
|
|
|
|
|
395
|
|
|
} else { |
|
396
|
|
|
$url = url($image); |
|
397
|
|
|
} |
|
398
|
|
|
} |
|
399
|
|
|
} |
|
400
|
|
|
|
|
401
|
|
|
return $url; |
|
402
|
|
|
} |
|
403
|
|
|
} |
|
404
|
|
|
|
Laravel-Backpack /
CRUD
Loading history...
This check marks parameter names that have not been written in camelCase.
In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes
databaseConnectionString.