<?php

namespace ProcessMaker\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;

use Illuminate\Support\Collection;

use Illuminate\Validation\ValidationException;

use ProcessMaker\Models\Process;

use ProcessMaker\Models\ProcessRequest;

use ProcessMaker\Traits\Exportable;

use Spatie\MediaLibrary\MediaCollections\Models\Media as MediaLibraryModel;

/**

* Represents media files stored in the database

*

* @property int 'id',

* @property int 'model_id',

* @property string 'model_type',

* @property string 'collection_name',

* @property string 'name',

* @property string 'file_name',

* @property string 'mime_type',

* @property string 'disk',

* @property string 'size',

* @property string 'manipulations',

* @property string 'custom_properties',

* @property string 'responsive_images',

* @property string 'order_column',

* @property \Carbon\Carbon $updated_at

* @property \Carbon\Carbon $created_at

*

* @OA\Schema(

* schema="mediaEditable",

* @OA\Property(property="id", type="integer", format="id"),

* @OA\Property(property="model_id", type="integer", format="id"),

* @OA\Property(property="model_type", type="string", format="id"),

* @OA\Property(property="collection_name", type="string"),

* @OA\Property(property="name", type="string"),

* @OA\Property(property="file_name", type="string"),

* @OA\Property(property="mime_type", type="string"),

* @OA\Property(property="disk", type="string"),

* @OA\Property(property="size", type="integer"),

* @OA\Property(property="manipulations", type="object"),

* @OA\Property(property="custom_properties", type="object"),

* @OA\Property(property="responsive_images", type="object"),

* @OA\Property(property="order_column", type="integer"),

* ),

* @OA\Schema(

* schema="media",

* allOf={@OA\Schema(ref="#/components/schemas/mediaEditable")},

* @OA\Property(property="created_at", type="string", format="date-time"),

* @OA\Property(property="updated_at", type="string", format="date-time"),

* ),

* @OA\Schema(

* schema="mediaExported",

* @OA\Property(property="url", type="string"),

* )

*/

class Media extends MediaLibraryModel

{

use Exportable;

use HasFactory;

protected $connection = 'processmaker';

protected $table = 'media';

const COLLECTION_SLIDESHOW = 'images_slideshow';

/**

* The attributes that are mass assignable.

*

* @var array

*/

protected $fillable = [

'model_id',

'model_type',

'collection_name',

'name',

'file_name',

'mime_type',

'disk',

'size',

'manipulations',

'custom_properties',

'responsive_images',

'order_column',

];

/**

* Validation rules

*

* @param $existing

*

* @return array

*/

public static function rules($existing = null)

{

return [

'model_id' => 'required',

'model_type' => 'required',

'collection_name' => 'required',

'name' => 'required,alpha_spaces',

'file_name' => 'required',

'mime_type' => 'required',

'disk' => 'required',

'size' => 'required',

'manipulations' => 'required',

'custom_properties' => 'required',

'responsive_images' => 'required',

'order_column' => 'required',

];

}

/**

* The binary UUID attributes that should be converted to text.

*

* @var array

*/

protected $ids = [

'model_id',

];

public function determineCollectionName(Process $process, $name)

{

// In order to differentiate them from other process-related images ['launchpad', 'slideshow']

if ($name === 'launchpad') {

return $process->uuid . '_' . 'images_carousel';

} elseif ($name === 'slideshow') {

return self::COLLECTION_SLIDESHOW;

}

return null;

}

/**

* Override the default boot method to allow access to lifecycle hooks

*

* @return null

*/

public static function boot()

{

parent::boot();

self::creating(function ($media) {

$user = pmUser();

if (!$media->hasCustomProperty('createdBy')) {

$media->setCustomProperty('createdBy', $user ? $user->id : null);

}

$media->setCustomProperty('updatedBy', $user ? $user->id : null);

});

self::saving(function ($media) {

if ($media->model instanceof ProcessRequest) {

if (empty($media->getCustomProperty('data_name'))) {

throw ValidationException::withMessages(['data_name' => 'data_name is required']);

}

}

$media->setCustomProperty('updatedBy', pmUser() ? pmUser()->id : null);

});

}

public function isPublicFile()

{

if ($this->model instanceof ProcessRequest) {

if ($this->model->process && $this->model->process->package_key == 'package-files/public-files') {

return true;

}

}

return false;

}

public function getManagerNameAttribute()

{

if (isset($this->custom_properties['data_name'])) {

return last(explode('/', $this->custom_properties['data_name']));

} else {

return $this->name;

}

}

public function getManagerUrlAttribute()

{

if ($this->isPublicFile()) {

$route = route('file-manager.index');

return $route . '#/public/' . $this->custom_properties['data_name'];

} else {

return route('requests.show.files.viewer', [

'request' => $this->model,

'filePath' => $this->custom_properties['data_name'],

]);

}

}

/**

* Save the media related to the Process

*

* @param Process $process

* @param array $properties

* @param string $key

* @param string $mediaType

*

* @return void

*/

public function saveProcessMedia(Process $process, $properties, $key = 'uuid', $mediaType = 'launchpad')

{

// Validate if the image smaller than 2MB

$maxFileSize = 2 * 1024 * 1024;

$imageData = base64_decode($properties['url']);

if (strlen($imageData) > $maxFileSize) {

return;

}

// Validate four images

$mediaCount = $process->getMedia()->count();

if ($mediaCount > 4) {

return;

}

// Get collection name to save

$collectionName = self::determineCollectionName($process, $mediaType);

// Check if exist

$exist = $process->media()->where($key, $properties[$key])->exists();

if (!$exist) {

// Define the custom properties

$customProperties = [

'media_type' => $mediaType,

'type' => $properties['type'],

];

if ($mediaType === 'slideshow') {

$customProperties['node_id'] = $properties['node_id'] ?? '';

$customProperties['alternative'] = $properties['alternative'] ?? '';

}

// Store the images related move to MEDIA

$media = $process->addMediaFromBase64($properties['url'])

->withCustomProperties($customProperties);

// Only if the file_name exist this will save

if (isset($properties['file_name']) && !empty($properties['file_name'])) {

$media->usingFileName($properties['file_name']);

}

// Add the media

$media->toMediaCollection($collectionName);

}

}

/**

* getFilesRequest

*

* @param ProcessRequest $request

* @return Collection | Media

*/

public static function getFilesRequest(ProcessRequest $request, $id = null)

{

$requestTokenIds = [$request->id];

if ($request->collaboration && $request->collaboration->requests()) {

// Get all processes and subprocesses request token id's ..

$requestTokenIds = $request->collaboration->requests->pluck('id')->toArray();

}

// Return a single file when $id is set

if ($id) {

try {

$mediaById = self::findOrFail($id);

} catch (\Exception) {

abort(400, __('Something went wrong and the file cannot be previewed or downloaded.'));

}

if (!in_array($mediaById->process_request_id, $requestTokenIds)) {

abort(404, __('File is not part of this request'));

}

return $mediaById;

}

// Get all files for process and all subprocesses ..

return self::where('model_type', ProcessRequest::class)

->whereIn('model_id', $requestTokenIds)->get();

}

public function getProcessRequestIdAttribute()

{

if ($this->model_type == TaskDraft::class) {

return $this->model->processRequestToken->processRequest->id;

} elseif ($this->model_type == ProcessRequest::class) {

return $this->model->id;

}

return null;

}

public function toArray()

{

$array = parent::toArray();

$array['process_request_id'] = $this->process_request_id;

return $array;

}

/**

* Check if the S3 is ready to use

*/

public static function s3IsReady()

{

return config('filesystems.disks.s3.key')

&& config('filesystems.disks.s3.secret')

&& config('filesystems.disks.s3.region')

&& config('filesystems.disks.s3.bucket');

}

}