file.php

<?php
namespace Bitrix\Landing;
 
use \Bitrix\Landing\Internals\FileTable;
 
class File
{
    public const ENTITY_TYPE_SITE  = 'S';
 
    public const ENTITY_TYPE_LANDING = 'L';
 
    public const ENTITY_TYPE_BLOCK = 'B';
 
    public const ENTITY_TYPE_ASSET = 'A';
 
    public static function transliterateFileName(string $fileName): string
    {
        $parts = pathinfo($fileName);
        $basename = $parts['filename'];
        $transliterateBaseName =  \CUtil::translit(
            $basename,
            'ru',
            [
                'replace_space' => '_',
                'replace_other' => '_'
            ]
        );
 
        return $transliterateBaseName . '.' . $parts['extension'];
    }
 
    public static function sanitizeFileName(string $fileName): string
    {
        return preg_replace(
            '/[\‍(\‍)\s]+/s',
            '_',
            $fileName
        );
    }
 
    protected static function add(int $fileId, int $entityId, string $entityType, bool $temp = false): void
    {
        $res = FileTable::getList(array(
            'select' => array(
                'ID'
            ),
            'filter' => array(
                'FILE_ID' => $fileId,
                'ENTITY_ID' => $entityId,
                '=ENTITY_TYPE' => $entityType
            )
        ));
        if (!$res->fetch())
        {
            $res = FileTable::add(array(
                'FILE_ID' => $fileId,
                'ENTITY_ID' => $entityId,
                'ENTITY_TYPE' => $entityType,
                'TEMP' => $temp ? 'Y' : 'N'
            ));
            $res->isSuccess();
        }
    }
 
    protected static function getFiles($entityId, $entityType)
    {
        $files = [];
        $res = FileTable::getList(array(
            'select' => array(
                'FILE_ID'
            ),
            'filter' => array(
                'ENTITY_ID' => $entityId,
                '=ENTITY_TYPE' => $entityType
            )
        ));
        while ($row = $res->fetch())
        {
            $files[] = $row['FILE_ID'];
        }
        return $files;
    }
 
    protected static function delete($fileId, $entityId, $entityType)
    {
        //@tmp log
        Debug::log(
            $entityId . '@' . $entityType,
            'fileId: ' . print_r($fileId, true) . '@' . print_r(\Bitrix\Main\Diag\Helper::getBackTrace(15), true),
            'LANDING_FILE_MARK_DELETE'
        );
 
        $filter = array(
            'ENTITY_ID' => $entityId,
            '=ENTITY_TYPE' => $entityType
        );
        if ($fileId)
        {
            $filter['FILE_ID'] = $fileId;
        }
        $res = FileTable::getList(array(
            'select' => array(
                'ID', 'FILE_ID'
            ),
            'filter' => $filter
        ));
        while ($row = $res->fetch())
        {
            $resUpdate = FileTable::update(
                $row['ID'],
                array(
                    'FILE_ID' => -1 * abs($row['FILE_ID'])
                )
            );
            $resUpdate->isSuccess();
        }
    }
 
    public static function deleteFinal($limit = null)
    {
        $deletedFiles = [];
 
        $res = FileTable::getList([
            'select' => [
                'ID', 'FILE_ID'
            ],
            'filter' => [
                '<FILE_ID' => 0
            ],
            'limit' => $limit,
            'order' => [
                'ID' => 'asc'
            ]
        ]);
        while ($row = $res->fetch())
        {
            $row['FILE_ID'] *= -1;
            FileTable::delete($row['ID']);
            $deletedFiles[$row['FILE_ID']] = $row['FILE_ID'];
        }
        if (!empty($deletedFiles))
        {
            // don't delete still used
            $res = FileTable::getList([
                'select' => [
                    'FILE_ID'
                ],
                'filter' => [
                    'FILE_ID' => $deletedFiles
                ]
            ]);
            while ($row = $res->fetch())
            {
                unset($deletedFiles[$row['FILE_ID']]);
            }
            foreach ($deletedFiles as $fid)
            {
                $fileData = self::getFileArray($fid);
                if ($fileData)
                {
                    //@tmp log
                    Debug::log(
                        $fileData['SRC'],
                        'fileId: ' . $fid,
                        'LANDING_FILE_DELETE'
                    );
                    \CFile::delete($fid);
                }
            }
        }
    }
 
    public static function addToSite(int $id, int $fileId, bool $temp = false): void
    {
        if ($fileId > 0 && $id > 0)
        {
            self::add($fileId, $id, self::ENTITY_TYPE_SITE, $temp);
        }
    }
 
    public static function getFilesFromSite($siteId)
    {
        return self::getFiles(
            $siteId,
            self::ENTITY_TYPE_SITE
        );
    }
 
    public static function deleteFromSite($id, $fileId = array())
    {
        self::delete($fileId, $id, self::ENTITY_TYPE_SITE);
    }
 
    public static function addToLanding($lid, $fileId)
    {
        if ($fileId > 0 && $lid > 0)
        {
            self::add($fileId, $lid, self::ENTITY_TYPE_LANDING);
        }
    }
 
    public static function getFilesFromLanding($landingId)
    {
        return self::getFiles(
            $landingId,
            self::ENTITY_TYPE_LANDING
        );
    }
 
    public static function deleteFromLanding($lid, $fileId = array())
    {
        self::delete($fileId, $lid, self::ENTITY_TYPE_LANDING);
    }
 
    public static function addToBlock(int $blockId, $fileId, bool $temp = false): void
    {
        if ($blockId > 0)
        {
            if (!is_array($fileId))
            {
                $fileId = array($fileId);
            }
            foreach ($fileId as $fid)
            {
                if ($fid > 0)
                {
                    self::add($fid, $blockId, self::ENTITY_TYPE_BLOCK, $temp);
                }
            }
        }
    }
 
    public static function replaceInBlock($blockId, $fileId)
    {
        if ($blockId > 0)
        {
            if (!is_array($fileId))
            {
                $fileId = array($fileId);
            }
            $res = FileTable::getList(array(
                'select' => array(
                    'FILE_ID'
                ),
                'filter' => array(
                    'ENTITY_ID' => $blockId,
                    '=ENTITY_TYPE' => self::ENTITY_TYPE_BLOCK
                )
            ));
            while ($row = $res->fetch())
            {
                if (!in_array($row['FILE_ID'], $fileId))
                {
                    self::delete($row['FILE_ID'], $blockId, self::ENTITY_TYPE_BLOCK);
                }
            }
            self::addToBlock($blockId, $fileId);
        }
    }
 
    public static function deleteFromBlock($blockId, $fileId = array())
    {
        self::delete($fileId, $blockId, self::ENTITY_TYPE_BLOCK);
    }
 
    public static function getFilesFromBlockContent($blockId, $content)
    {
        $fileIds = array();
        // parse from content
        if (preg_match_all('/data-fileid[2x]{0,2}="([\d]+)"/i', $content, $matches))
        {
            foreach ($matches[1] as $fid)
            {
                $fileIds[] = $fid;
            }
        }
        // check if files ids set in blockId
        if (!empty($fileIds))
        {
            $res = FileTable::getList(array(
                'select' => array(
                    'FILE_ID'
                ),
                'filter' => array(
                    'FILE_ID' => $fileIds,
                    'ENTITY_ID' => $blockId,
                    '=ENTITY_TYPE' => self::ENTITY_TYPE_BLOCK
                )
            ));
            $fileIds = array();
            while ($row = $res->fetch())
            {
                $fileIds[] = $row['FILE_ID'];
            }
        }
        return $fileIds;
    }
 
    public static function getFilesFromBlock($blockId)
    {
        return self::getFiles(
            $blockId,
            self::ENTITY_TYPE_BLOCK
        );
    }
 
    public static function addToAsset($assetId, $fileId): void
    {
        if ($fileId > 0 && $assetId > 0)
        {
            self::add($fileId, $assetId, self::ENTITY_TYPE_ASSET);
            self::markAssetRebuilded($assetId);
            // todo: res from add and check error
        }
    }
 
    public static function getFilesFromAsset($assetId): array
    {
        return self::getFiles(
            $assetId,
            self::ENTITY_TYPE_ASSET
        );
    }
 
    public static function deleteFromAsset(int $assetId, $fileId = []): void
    {
        self::delete($fileId, $assetId, self::ENTITY_TYPE_ASSET);
    }
 
    public static function markAssetToRebuild($assetId = []): bool
    {
        $filter = [
            '=ENTITY_TYPE' => self::ENTITY_TYPE_ASSET
        ];
        if ($assetId)
        {
            $filter['ENTITY_ID'] = $assetId;
        }
 
        $res = FileTable::getList([
            'select' => ['ID', 'ENTITY_ID'],
            'filter' => $filter
        ]);
        $files = $res->fetchAll();
        $result = true;
        foreach ($files as $file)
        {
            $resUpdate = FileTable::update(
                $file['ID'],
                [
                    'ENTITY_ID' => -1 * abs($file['ENTITY_ID'])
                ]
            );
            $result = $result && $resUpdate->isSuccess();
        }
 
        return count($files) > 0 ? $result : false;
    }
 
    public static function markAssetRebuilded($assetId): void
    {
        if(!is_array($assetId))
        {
            $assetId = [$assetId];
        }
 
        foreach ($assetId as $key => $id)
        {
            self::deleteFromAsset(-1 * abs($id));
        }
    }
 
    protected static function copyEntityFiles($from, $to, $entityType)
    {
        $res = FileTable::getList(array(
            'select' => array(
                'FILE_ID'
            ),
            'filter' => array(
                'ENTITY_ID' => $from,
                '=ENTITY_TYPE' => $entityType
            )
        ));
        while ($row = $res->fetch())
        {
            FileTable::add(array(
                'FILE_ID' => $row['FILE_ID'],
                'ENTITY_ID' => $to,
                'ENTITY_TYPE' => $entityType
            ));
        }
    }
 
    public static function copySiteFiles($from, $to)
    {
        self::copyEntityFiles($from, $to, self::ENTITY_TYPE_SITE);
    }
 
    public static function copyLandingFiles($from, $to)
    {
        self::copyEntityFiles($from, $to, self::ENTITY_TYPE_LANDING);
    }
 
    public static function copyBlockFiles($from, $to)
    {
        self::copyEntityFiles($from, $to, self::ENTITY_TYPE_BLOCK);
    }
 
    public static function getFileArray($fileId)
    {
        $file = \CFile::getFileArray(
            $fileId
        );
        if (
            isset($file['MODULE_ID']) &&
            $file['MODULE_ID'] == 'landing'
        )
        {
            return $file;
        }
        return false;
    }
 
    public static function getFilePath($fileId): ?string
    {
        $file = self::getFileArray($fileId);
        if (isset($file['SRC']))
        {
            return $file['SRC'];
        }
        return null;
    }
 
    public static function releaseFile(int $fileId): void
    {
        $res = FileTable::getList(array(
            'select' => [
                'ID'
            ],
            'filter' => [
                'FILE_ID' => $fileId
            ]
        ));
        while ($row = $res->fetch())
        {
            FileTable::delete($row['ID']);
        }
    }
 
    public static function deletePhysical(int $fileId): void
    {
        if (self::getFileArray($fileId))
        {
            self::releaseFile($fileId);
            \CFile::delete($fileId);
        }
    }
}