ImageCopier::copyToRemoteSite() - Code Metrics - pryley/site-reviews - Measure and Improve Code Quality continuously with Scrutinizer

ImageCopier::copyToRemoteSite() B
last analyzed 2025-12-01 22:28 UTC

↳ Parent: ImageCopier

Complexity

Conditions	10
Paths	7

Size

Total Lines	38
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	29
dl	0
loc	38
rs	7.6666
c	1
b	0
f	0
cc	10
nc	7
nop	1

How to fix Complexity

<?php

namespace GeminiLabs\SiteReviews\Integrations\MultilingualPress;

use GeminiLabs\SiteReviews\Database;
use GeminiLabs\SiteReviews\Database\Query;
use GeminiLabs\SiteReviews\Helpers\Cast;
use GeminiLabs\SiteReviews\Helpers\Str;
use Inpsyde\MultilingualPress\Editor\Notices\ExistingAttachmentsNotice;
use Inpsyde\MultilingualPress\Framework\Filesystem;
use Inpsyde\MultilingualPress\Framework\SwitchSiteTrait;
use Inpsyde\MultilingualPress\TranslationUi\Post\RelationshipContext;

class ImageCopier
{
    use SwitchSiteTrait;

    protected RelationshipContext $context;
    protected ExistingAttachmentsNotice $existingAttachmentsNotice;
    protected Filesystem $filesystem;

    public function __construct(
        Filesystem $filesystem,
        ExistingAttachmentsNotice $existingAttachmentsNotice
    ) {
        $this->existingAttachmentsNotice = $existingAttachmentsNotice;
        $this->filesystem = $filesystem;
    }

    /**
     * Retrieve the attachment id of the existing attachment based on the file name.
     */
    public function attachmentIdFromPath(string $attachmentPath): int
    {
        return $this->existingAttachmentId($attachmentPath);
    }

    /**
     * Copy attachments from source site to the give remote site using a list of attachment ids.
     */
    public function copyById(int $sourceSiteId, int $remoteSiteId, array $sourceAttachmentIds): array
    {
        $this->context = new RelationshipContext([
            RelationshipContext::REMOTE_SITE_ID => $remoteSiteId,
            RelationshipContext::SOURCE_SITE_ID => $sourceSiteId,
        ]);
        return $this->copyAttachmentsFromSource($sourceAttachmentIds);
    }

    /**
     * Copy attachments from source site to the give remote site using a list of attachment ids.
     */
    public function copyByIdWithContext(RelationshipContext $context, array $sourceAttachmentIds): array
    {
        $this->context = $context;
        return $this->copyAttachmentsFromSource($sourceAttachmentIds);
    }

    /**
     * Retrieve the meta by the given attachment post.
     */
    protected function attachmentMeta(\WP_Post $attachment): array
    {
        $altMeta = (string) get_post_meta($attachment->ID, '_wp_attachment_image_alt', true);
        $sourceUrl = (string) get_post_meta($attachment->ID, '_source_url', true);
        return array_filter([
            '_source_url' => sanitize_url($sourceUrl), // this will exist if the image was imported from a CSV file
            '_wp_attachment_image_alt' => sanitize_text_field($altMeta),
        ]);
    }

    protected function copyAttachmentIds(array $sourceAttachmentIds): array
    {
        $sourceAttachmentIds = $this->ensureAttachmentIds($sourceAttachmentIds);
        $sourceAttachments = $this->sourceAttachments($sourceAttachmentIds);
        return $sourceAttachments
            ? $this->copyToRemoteSite(...$sourceAttachments)
            : [];
    }

    protected function copyAttachmentsFromSource(array $sourceAttachmentIds): array
    {
        $attachmentIds = [];
        $reviewAttachmentIds = [];
        if (class_exists('GeminiLabs\SiteReviews\Addon\Images\Uploader')) {
            $reviewAttachmentIds = array_filter($sourceAttachmentIds,
                fn ($attachmentId) => str_contains((string) get_attached_file($attachmentId, true), 'site-reviews/')
            );
            if (!empty($reviewAttachmentIds)) {
                glsr('Addon\Images\Uploader')->setUploadPath(glsr()->id);
                glsr('Addon\Images\Uploader')->setIntermediateImageSizes();
                $attachmentIds = $this->copyAttachmentIds($reviewAttachmentIds);
                glsr('Addon\Images\Uploader')->resetIntermediateImageSizes();
                glsr('Addon\Images\Uploader')->resetUploadPath();
            }
        }
        if ($otherAttachmentIds = array_diff($sourceAttachmentIds, $reviewAttachmentIds)) {
            $copiedAttachmentIds = $this->copyAttachmentIds($otherAttachmentIds);
            return array_merge($attachmentIds, $copiedAttachmentIds);
        }
        return $attachmentIds;
    }

    /**
     * Copy the attachment meta from the source give post to the remote attachment.
     */
    protected function copyMetaFromSourceAttachment(
        AttachmentData $sourceAttachmentData,
        int $remoteAttachmentId
    ): void {
        foreach ($sourceAttachmentData->meta() as $attachmentKey => $sourceAttachmentMeta) {
            update_post_meta($remoteAttachmentId, $attachmentKey, $sourceAttachmentMeta);
        }
    }

    /**
     * Copy the attachment sizes from the given source post to the remote site.
     */
    protected function copySizesFromSourceAttachment(
        AttachmentData $sourceAttachmentData,
        int $remoteAttachmentId
    ): void {
        $remoteUploadPath = wp_upload_dir()['path'] ?? '';
        $sourceUploadPath = dirname($sourceAttachmentData->filePath());
        $sourceAttachmentBasename = wp_basename($sourceAttachmentData->filePath());
        $remoteAttachmentRealPath = "{$remoteUploadPath}/{$sourceAttachmentBasename}";
        $metadata = $sourceAttachmentData->fileMeta();
        $sizes = wp_get_registered_image_subsizes();
        $sizes = apply_filters('intermediate_image_sizes_advanced', $sizes, $metadata, $remoteAttachmentId);
        $copiedSizes = [];
        foreach (($metadata['sizes'] ?? []) as $size => $meta) {
            if (!array_key_exists($size, $sizes)) {
                continue;
            }
            $sourceFile = "{$sourceUploadPath}/{$meta['file']}";
            $remoteFile = "{$remoteUploadPath}/{$meta['file']}";
            if ($this->filesystem->pathExists($remoteFile) && $this->filesystem->isReadable($remoteFile)) {
                $copiedSizes[$size] = $meta;
                continue;
            }
            if ($this->filesystem->copy($sourceFile, $remoteFile)) {
                $copiedSizes[$size] = $meta;
                continue;
            }
            $meta = image_make_intermediate_size(
                $remoteAttachmentRealPath,
                $sizes[$size]['width'] ?? null,
                $sizes[$size]['height'] ?? null,
                $sizes[$size]['crop'] ?? false
            );
            if ($meta) {
                $copiedSizes[$size] = $meta;
            }
        }
        $metadata['sizes'] = $copiedSizes;
        if (empty($metadata['sizes'])) {
            $metadata = wp_generate_attachment_metadata($remoteAttachmentId, $remoteAttachmentRealPath);
        }
        wp_update_attachment_metadata($remoteAttachmentId, $metadata);
    }

    /**
     * Copy attachment file to the remote upload dir and create a new attachment post.
     */
    protected function copyToRemoteSite(AttachmentData ...$sourceAttachmentsData): array
    {
        $originalSite = $this->maybeSwitchSite($this->context->remoteSiteId());
        $remoteAttachments = [];
        $uploadDir = wp_upload_dir();
        $uploadPath = $uploadDir['path'] ?? '';
        $uploadUrl = $uploadDir['url'] ?? '';
        if (!$uploadPath || !$uploadUrl || !$this->filesystem->mkDirP($uploadDir['path'])) {
            $this->maybeRestoreSite($originalSite);
            return [];
        }
        foreach ($sourceAttachmentsData as $sourceAttachmentData) {
            $sourceAttachmentPath = $sourceAttachmentData->filePath();
            $sourceAttachmentBasename = wp_basename($sourceAttachmentPath);
            if ($existingAttachmentId = $this->existingAttachmentId($sourceAttachmentData->relativePath())) {
                $updatedId = $this->updateAttachment($sourceAttachmentData, $existingAttachmentId);
                if ($updatedId) {
                    $remoteAttachments[] = $updatedId;
                }
                continue;
            }
            $remoteAttachmentRealPath = "{$uploadPath}/{$sourceAttachmentBasename}";
            $remoteAttachmentUrl = "{$uploadUrl}/{$sourceAttachmentBasename}";
            if (!$this->filesystem->pathExists($sourceAttachmentPath)
                || !$this->filesystem->isReadable($sourceAttachmentPath)) {
                continue;
            }
            if (!$this->filesystem->copy($sourceAttachmentPath, $remoteAttachmentRealPath)) {
                continue;
            }
            $remoteAttachments[] = $this->createAttachmentPostByPath(
                $sourceAttachmentData,
                $remoteAttachmentRealPath,
                $remoteAttachmentUrl
            );
        }
        $this->maybeRestoreSite($originalSite);
        return array_filter($remoteAttachments);
    }

    /**
     * Create an attachment post by the attachment path.
     */
    protected function createAttachmentPostByPath(
        AttachmentData $sourceAttachmentData,
        string $remoteAttachmentRealPath,
        string $remoteAttachmentUrl
    ): int {
        $filetype = wp_check_filetype($remoteAttachmentRealPath);
        $sourceAttachment = $sourceAttachmentData->post();
        $remoteAttachmentData = [
            'guid' => $remoteAttachmentUrl,
            'menu_order' => $sourceAttachment->menu_order,
            'post_author' => get_current_user_id(),
            'post_content' => $sourceAttachment->post_content,
            'post_excerpt' => $sourceAttachment->post_excerpt,
            'post_mime_type' => $filetype['type'] ?? '',
            'post_title' => $sourceAttachment->post_title,
        ];
        $this->requireAttachmentFunctions();
        $remoteAttachmentId = wp_insert_attachment(
            $remoteAttachmentData,
            $remoteAttachmentRealPath,
            $this->context->remotePostId(), // attach to the remote post
        );
        if ($remoteAttachmentId instanceof \WP_Error) {
            return 0;
        }
        $this->copyMetaFromSourceAttachment(
            $sourceAttachmentData,
            $remoteAttachmentId
        );
        $this->copySizesFromSourceAttachment(
            $sourceAttachmentData,
            $remoteAttachmentId
        );
        return $remoteAttachmentId;
    }

    /**
     * Ensure attachment ids are valid integer values.
     */
    protected function ensureAttachmentIds(array $attachmentIds): array
    {
        return array_filter(wp_parse_id_list($attachmentIds));
    }

    /**
     * Retrieve the attachment id of the existing attachment based on the file name.
     */
    protected function existingAttachmentId(string $attachmentPath): int
    {
        $relativeAttachmentPath = Str::removePrefix(
            $attachmentPath,
            trailingslashit(wp_upload_dir()['basedir'] ?? '')
        );
        $sql = glsr(Query::class)->sql("
            SELECT post_id
            FROM table|postmeta
            WHERE meta_key = '_wp_attached_file'
            AND meta_value LIKE %s
        ", "%{$relativeAttachmentPath}");
        return Cast::toInt(glsr(Database::class)->dbGetVar($sql));
    }

    /**
     * Check if an attachment post is a valid attachment.
     */
    protected function isLocalAttachment(\WP_Post $attachment): bool
    {
        return is_local_attachment((string) get_permalink($attachment));
    }

    /**
     * Require functions to work with attachments.
     */
    protected function requireAttachmentFunctions(): void
    {
        if (!\function_exists('wp_generate_attachment_metadata')
            && !\function_exists('MultilingualPress\Vendor\wp_generate_attachment_metadata')) {
            require_once ABSPATH.'wp-admin/includes/image.php';
        }
        if (!\function_exists('get_intermediate_image_sizes')) {
            require_once ABSPATH.'wp-admin/includes/media.php';
        }
    }

    /**
     * Retrieve the attachments post and files path
     * The items contains the post and the real path of the attachment.
     *
     * @param int[] $attachmentIds
     *
     * @return AttachmentData[]
     */
    protected function sourceAttachments(array $attachmentIds): array
    {
        $sourceAttachments = [];
        foreach ($attachmentIds as $attachmentId) {
            $attachment = get_post($attachmentId);
            if (!$attachment instanceof \WP_Post || !$this->isLocalAttachment($attachment)) {
                continue;
            }
            $attachmentPath = get_attached_file($attachmentId, true); // unfiltered
            if (!$attachmentPath) {
                continue;
            }
            $relativeAttachmentPath = Str::removePrefix(
                $attachmentPath,
                trailingslashit(wp_upload_dir()['basedir'] ?? '')
            );
            $sourceAttachments[$attachmentId] = new AttachmentData(
                $attachment,
                $this->attachmentMeta($attachment),
                $attachmentPath,
                $relativeAttachmentPath
            );
        }
        return $sourceAttachments;
    }

    /**
     * Update the remote attachment post meta data with data provided by the given source attachment.
     */
    protected function updateAttachment(
        AttachmentData $sourceAttachmentData,
        int $remoteAttachmentId
    ): int {
        $data = $sourceAttachmentData->post()->to_array();
        $data['ID'] = $remoteAttachmentId;
        $data['post_parent'] = $this->context->remotePostId(); // attach to the remote post
        $attachmentId = wp_update_post($data, true);
        if (is_wp_error($attachmentId)) {
            $this->existingAttachmentsNotice->addAttachment(
                $sourceAttachmentData->post()->ID,
                $this->context->remoteSiteId()
            );
            return 0;
        }
        $this->copyMetaFromSourceAttachment(
            $sourceAttachmentData,
            $remoteAttachmentId
        );
        $this->copySizesFromSourceAttachment(
            $sourceAttachmentData,
            $remoteAttachmentId
        );
        return $attachmentId;
    }
}


1			<?php
2
3			namespace GeminiLabs\SiteReviews\Integrations\MultilingualPress;
4
5			use GeminiLabs\SiteReviews\Database;
6			use GeminiLabs\SiteReviews\Database\Query;
7			use GeminiLabs\SiteReviews\Helpers\Cast;
8			use GeminiLabs\SiteReviews\Helpers\Str;
9			use Inpsyde\MultilingualPress\Editor\Notices\ExistingAttachmentsNotice;
10			use Inpsyde\MultilingualPress\Framework\Filesystem;
11			use Inpsyde\MultilingualPress\Framework\SwitchSiteTrait;
12			use Inpsyde\MultilingualPress\TranslationUi\Post\RelationshipContext;
13
14			class ImageCopier
15			{
16			use SwitchSiteTrait;
17
18			protected RelationshipContext $context;
19			protected ExistingAttachmentsNotice $existingAttachmentsNotice;
20			protected Filesystem $filesystem;
21
22			public function __construct(
23			Filesystem $filesystem,
24			ExistingAttachmentsNotice $existingAttachmentsNotice
25			) {
26			$this->existingAttachmentsNotice = $existingAttachmentsNotice;
27			$this->filesystem = $filesystem;
28			}
29
30			/**
31			* Retrieve the attachment id of the existing attachment based on the file name.
32			*/
33			public function attachmentIdFromPath(string $attachmentPath): int
34			{
35			return $this->existingAttachmentId($attachmentPath);
36			}
37
38			/**
39			* Copy attachments from source site to the give remote site using a list of attachment ids.
40			*/
41			public function copyById(int $sourceSiteId, int $remoteSiteId, array $sourceAttachmentIds): array
42			{
43			$this->context = new RelationshipContext([
44			RelationshipContext::REMOTE_SITE_ID => $remoteSiteId,
45			RelationshipContext::SOURCE_SITE_ID => $sourceSiteId,
46			]);
47			return $this->copyAttachmentsFromSource($sourceAttachmentIds);
48			}
49
50			/**
51			* Copy attachments from source site to the give remote site using a list of attachment ids.
52			*/
53			public function copyByIdWithContext(RelationshipContext $context, array $sourceAttachmentIds): array
54			{
55			$this->context = $context;
56			return $this->copyAttachmentsFromSource($sourceAttachmentIds);
57			}
58
59			/**
60			* Retrieve the meta by the given attachment post.
61			*/
62			protected function attachmentMeta(\WP_Post $attachment): array
63			{
64			$altMeta = (string) get_post_meta($attachment->ID, '_wp_attachment_image_alt', true);
65			$sourceUrl = (string) get_post_meta($attachment->ID, '_source_url', true);
66			return array_filter([
67			'_source_url' => sanitize_url($sourceUrl), // this will exist if the image was imported from a CSV file
68			'_wp_attachment_image_alt' => sanitize_text_field($altMeta),
69			]);
70			}
71
72			protected function copyAttachmentIds(array $sourceAttachmentIds): array
73			{
74			$sourceAttachmentIds = $this->ensureAttachmentIds($sourceAttachmentIds);
75			$sourceAttachments = $this->sourceAttachments($sourceAttachmentIds);
76			return $sourceAttachments
77			? $this->copyToRemoteSite(...$sourceAttachments)
78			: [];
79			}
80
81			protected function copyAttachmentsFromSource(array $sourceAttachmentIds): array
82			{
83			$attachmentIds = [];
84			$reviewAttachmentIds = [];
85			if (class_exists('GeminiLabs\SiteReviews\Addon\Images\Uploader')) {
86			$reviewAttachmentIds = array_filter($sourceAttachmentIds,
87			fn ($attachmentId) => str_contains((string) get_attached_file($attachmentId, true), 'site-reviews/')
88			);
89			if (!empty($reviewAttachmentIds)) {
90			glsr('Addon\Images\Uploader')->setUploadPath(glsr()->id);
91			glsr('Addon\Images\Uploader')->setIntermediateImageSizes();
92			$attachmentIds = $this->copyAttachmentIds($reviewAttachmentIds);
93			glsr('Addon\Images\Uploader')->resetIntermediateImageSizes();
94			glsr('Addon\Images\Uploader')->resetUploadPath();
95			}
96			}
97			if ($otherAttachmentIds = array_diff($sourceAttachmentIds, $reviewAttachmentIds)) {
98			$copiedAttachmentIds = $this->copyAttachmentIds($otherAttachmentIds);
99			return array_merge($attachmentIds, $copiedAttachmentIds);
100			}
101			return $attachmentIds;
102			}
103
104			/**
105			* Copy the attachment meta from the source give post to the remote attachment.
106			*/
107			protected function copyMetaFromSourceAttachment(
108			AttachmentData $sourceAttachmentData,
109			int $remoteAttachmentId
110			): void {
111			foreach ($sourceAttachmentData->meta() as $attachmentKey => $sourceAttachmentMeta) {
112			update_post_meta($remoteAttachmentId, $attachmentKey, $sourceAttachmentMeta);
113			}
114			}
115
116			/**
117			* Copy the attachment sizes from the given source post to the remote site.
118			*/
119			protected function copySizesFromSourceAttachment(
120			AttachmentData $sourceAttachmentData,
121			int $remoteAttachmentId
122			): void {
123			$remoteUploadPath = wp_upload_dir()['path'] ?? '';
124			$sourceUploadPath = dirname($sourceAttachmentData->filePath());
125			$sourceAttachmentBasename = wp_basename($sourceAttachmentData->filePath());
126			$remoteAttachmentRealPath = "{$remoteUploadPath}/{$sourceAttachmentBasename}";
127			$metadata = $sourceAttachmentData->fileMeta();
128			$sizes = wp_get_registered_image_subsizes();
129			$sizes = apply_filters('intermediate_image_sizes_advanced', $sizes, $metadata, $remoteAttachmentId);
130			$copiedSizes = [];
131			foreach (($metadata['sizes'] ?? []) as $size => $meta) {
132			if (!array_key_exists($size, $sizes)) {
133			continue;
134			}
135			$sourceFile = "{$sourceUploadPath}/{$meta['file']}";
136			$remoteFile = "{$remoteUploadPath}/{$meta['file']}";
137			if ($this->filesystem->pathExists($remoteFile) && $this->filesystem->isReadable($remoteFile)) {
138			$copiedSizes[$size] = $meta;
139			continue;
140			}
141			if ($this->filesystem->copy($sourceFile, $remoteFile)) {
142			$copiedSizes[$size] = $meta;
143			continue;
144			}
145			$meta = image_make_intermediate_size(
146			$remoteAttachmentRealPath,
147			$sizes[$size]['width'] ?? null,
148			$sizes[$size]['height'] ?? null,
149			$sizes[$size]['crop'] ?? false
150			);
151			if ($meta) {
152			$copiedSizes[$size] = $meta;
153			}
154			}
155			$metadata['sizes'] = $copiedSizes;
156			if (empty($metadata['sizes'])) {
157			$metadata = wp_generate_attachment_metadata($remoteAttachmentId, $remoteAttachmentRealPath);
158			}
159			wp_update_attachment_metadata($remoteAttachmentId, $metadata);
160			}
161
162			/**
163			* Copy attachment file to the remote upload dir and create a new attachment post.
164			*/
165			protected function copyToRemoteSite(AttachmentData ...$sourceAttachmentsData): array
166			{
167			$originalSite = $this->maybeSwitchSite($this->context->remoteSiteId());
168			$remoteAttachments = [];
169			$uploadDir = wp_upload_dir();
170			$uploadPath = $uploadDir['path'] ?? '';
171			$uploadUrl = $uploadDir['url'] ?? '';
172			if (!$uploadPath \|\| !$uploadUrl \|\| !$this->filesystem->mkDirP($uploadDir['path'])) {
173			$this->maybeRestoreSite($originalSite);
174			return [];
175			}
176			foreach ($sourceAttachmentsData as $sourceAttachmentData) {
177			$sourceAttachmentPath = $sourceAttachmentData->filePath();
178			$sourceAttachmentBasename = wp_basename($sourceAttachmentPath);
179			if ($existingAttachmentId = $this->existingAttachmentId($sourceAttachmentData->relativePath())) {
180			$updatedId = $this->updateAttachment($sourceAttachmentData, $existingAttachmentId);
181			if ($updatedId) {
182			$remoteAttachments[] = $updatedId;
183			}
184			continue;
185			}
186			$remoteAttachmentRealPath = "{$uploadPath}/{$sourceAttachmentBasename}";
187			$remoteAttachmentUrl = "{$uploadUrl}/{$sourceAttachmentBasename}";
188			if (!$this->filesystem->pathExists($sourceAttachmentPath)
189			\|\| !$this->filesystem->isReadable($sourceAttachmentPath)) {
190			continue;
191			}
192			if (!$this->filesystem->copy($sourceAttachmentPath, $remoteAttachmentRealPath)) {
193			continue;
194			}
195			$remoteAttachments[] = $this->createAttachmentPostByPath(
196			$sourceAttachmentData,
197			$remoteAttachmentRealPath,
198			$remoteAttachmentUrl
199			);
200			}
201			$this->maybeRestoreSite($originalSite);
202			return array_filter($remoteAttachments);
203			}
204
205			/**
206			* Create an attachment post by the attachment path.
207			*/
208			protected function createAttachmentPostByPath(
209			AttachmentData $sourceAttachmentData,
210			string $remoteAttachmentRealPath,
211			string $remoteAttachmentUrl
212			): int {
213			$filetype = wp_check_filetype($remoteAttachmentRealPath);
214			$sourceAttachment = $sourceAttachmentData->post();
215			$remoteAttachmentData = [
216			'guid' => $remoteAttachmentUrl,
217			'menu_order' => $sourceAttachment->menu_order,
218			'post_author' => get_current_user_id(),
219			'post_content' => $sourceAttachment->post_content,
220			'post_excerpt' => $sourceAttachment->post_excerpt,
221			'post_mime_type' => $filetype['type'] ?? '',
222			'post_title' => $sourceAttachment->post_title,
223			];
224			$this->requireAttachmentFunctions();
225			$remoteAttachmentId = wp_insert_attachment(
226			$remoteAttachmentData,
227			$remoteAttachmentRealPath,
228			$this->context->remotePostId(), // attach to the remote post
229			);
230			if ($remoteAttachmentId instanceof \WP_Error) {
231			return 0;
232			}
233			$this->copyMetaFromSourceAttachment(
234			$sourceAttachmentData,
235			$remoteAttachmentId
236			);
237			$this->copySizesFromSourceAttachment(
238			$sourceAttachmentData,
239			$remoteAttachmentId
240			);
241			return $remoteAttachmentId;
242			}
243
244			/**
245			* Ensure attachment ids are valid integer values.
246			*/
247			protected function ensureAttachmentIds(array $attachmentIds): array
248			{
249			return array_filter(wp_parse_id_list($attachmentIds));
250			}
251
252			/**
253			* Retrieve the attachment id of the existing attachment based on the file name.
254			*/
255			protected function existingAttachmentId(string $attachmentPath): int
256			{
257			$relativeAttachmentPath = Str::removePrefix(
258			$attachmentPath,
259			trailingslashit(wp_upload_dir()['basedir'] ?? '')
260			);
261			$sql = glsr(Query::class)->sql("
262			SELECT post_id
263			FROM table\|postmeta
264			WHERE meta_key = '_wp_attached_file'
265			AND meta_value LIKE %s
266			", "%{$relativeAttachmentPath}");
267			return Cast::toInt(glsr(Database::class)->dbGetVar($sql));
268			}
269
270			/**
271			* Check if an attachment post is a valid attachment.
272			*/
273			protected function isLocalAttachment(\WP_Post $attachment): bool
274			{
275			return is_local_attachment((string) get_permalink($attachment));
276			}
277
278			/**
279			* Require functions to work with attachments.
280			*/
281			protected function requireAttachmentFunctions(): void
282			{
283			if (!\function_exists('wp_generate_attachment_metadata')
284			&& !\function_exists('MultilingualPress\Vendor\wp_generate_attachment_metadata')) {
285			require_once ABSPATH.'wp-admin/includes/image.php';
286			}
287			if (!\function_exists('get_intermediate_image_sizes')) {
288			require_once ABSPATH.'wp-admin/includes/media.php';
289			}
290			}
291
292			/**
293			* Retrieve the attachments post and files path
294			* The items contains the post and the real path of the attachment.
295			*
296			* @param int[] $attachmentIds
297			*
298			* @return AttachmentData[]
299			*/
300			protected function sourceAttachments(array $attachmentIds): array
301			{
302			$sourceAttachments = [];
303			foreach ($attachmentIds as $attachmentId) {
304			$attachment = get_post($attachmentId);
305			if (!$attachment instanceof \WP_Post \|\| !$this->isLocalAttachment($attachment)) {
306			continue;
307			}
308			$attachmentPath = get_attached_file($attachmentId, true); // unfiltered
309			if (!$attachmentPath) {
310			continue;
311			}
312			$relativeAttachmentPath = Str::removePrefix(
313			$attachmentPath,
314			trailingslashit(wp_upload_dir()['basedir'] ?? '')
315			);
316			$sourceAttachments[$attachmentId] = new AttachmentData(
317			$attachment,
318			$this->attachmentMeta($attachment),
319			$attachmentPath,
320			$relativeAttachmentPath
321			);
322			}
323			return $sourceAttachments;
324			}
325
326			/**
327			* Update the remote attachment post meta data with data provided by the given source attachment.
328			*/
329			protected function updateAttachment(
330			AttachmentData $sourceAttachmentData,
331			int $remoteAttachmentId
332			): int {
333			$data = $sourceAttachmentData->post()->to_array();
334			$data['ID'] = $remoteAttachmentId;
335			$data['post_parent'] = $this->context->remotePostId(); // attach to the remote post
336			$attachmentId = wp_update_post($data, true);
337			if (is_wp_error($attachmentId)) {
338			$this->existingAttachmentsNotice->addAttachment(
339			$sourceAttachmentData->post()->ID,
340			$this->context->remoteSiteId()
341			);
342			return 0;
343			}
344			$this->copyMetaFromSourceAttachment(
345			$sourceAttachmentData,
346			$remoteAttachmentId
347			);
348			$this->copySizesFromSourceAttachment(
349			$sourceAttachmentData,
350			$remoteAttachmentId
351			);
352			return $attachmentId;
353			}
354			}
355

pryley / site-reviews

ImageCopier::copyToRemoteSite() B last analyzed 2025-12-01 22:28 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ImageCopier::copyToRemoteSite() B
last analyzed 2025-12-01 22:28 UTC