public static ImageOptimizationResponse ConvertToResponse(this KrakenResponse krakenResponse)
        {
            if (krakenResponse == null)
            {
                return(new ImageOptimizationResponse());
            }

            var webClient = new WebClient();

            var imageOptimizationResponse = new ImageOptimizationResponse
            {
                OriginalImageUrl   = krakenResponse.file_name,
                OriginalImageSize  = krakenResponse.original_size,
                PercentSaved       = (krakenResponse.kraked_size / krakenResponse.original_size) * 100,
                OptimizedImageSize = krakenResponse.kraked_size,
                ErrorMessage       = "An error has occurred while compressing image"
            };

            if (!string.IsNullOrEmpty(krakenResponse.file_name))
            {
                imageOptimizationResponse.OptimizedImage = webClient.DownloadData(krakenResponse.kraked_url);
                imageOptimizationResponse.Successful     = true;
            }

            return(imageOptimizationResponse);
        }
Esempio n. 2
0
        public static ImageOptimizationResponse ConvertToResponse(this SmushItResponse smushItResponse)
        {
            if (smushItResponse == null)
            {
                return(new ImageOptimizationResponse());
            }

            var webClient = new WebClient();

            var imageOptimizationResponse = new ImageOptimizationResponse
            {
                OriginalImageUrl   = smushItResponse.Src,
                OriginalImageSize  = smushItResponse.Src_Size,
                PercentSaved       = smushItResponse.Percent,
                OptimizedImageSize = smushItResponse.Dest_Size,
                ErrorMessage       = smushItResponse.Error
            };

            if (!string.IsNullOrEmpty(smushItResponse.Dest))
            {
                imageOptimizationResponse.OptimizedImage = webClient.DownloadData(smushItResponse.Dest);
                imageOptimizationResponse.Successful     = true;
            }

            return(imageOptimizationResponse);
        }
Esempio n. 3
0
        private Identity AddLogEntry(ImageOptimizationResponse imageOptimizationResponse, ImageData imageData)
        {
            ImageLogEntry logEntry = this._imageLogRepository.GetLogEntry(imageOptimizationResponse.OriginalImageUrl) ?? new ImageLogEntry();

            logEntry.ContentGuid   = imageData.ContentGuid;
            logEntry.OriginalSize  = imageOptimizationResponse.OriginalImageSize;
            logEntry.OptimizedSize = imageOptimizationResponse.OptimizedImageSize;
            logEntry.PercentSaved  = imageOptimizationResponse.PercentSaved;
            logEntry.ImageUrl      = imageOptimizationResponse.OriginalImageUrl;

            return(this._imageLogRepository.Save(logEntry));
        }
Esempio n. 4
0
        public override string Execute()
        {
            int  count            = 0;
            long totalBytesBefore = 0;
            long totalBytesAfter  = 0;

            var contentRepository = ServiceLocator.Current.GetInstance <IContentRepository>();
            var blobFactory       = ServiceLocator.Current.GetInstance <BlobFactory>();

            IEnumerable <ImageData> allImages = GetFolders(contentRepository).SelectMany(GetImageFiles).Distinct();

            if (_stop)
            {
                return($"Job stopped after optimizing {count} images.");
            }

            if (!ImageOptimizationSettings.Instance.BypassPreviouslyOptimized)
            {
                allImages = FilterPreviouslyOptimizedImages(allImages);
            }

            foreach (ImageData image in allImages)
            {
                if (_stop)
                {
                    return
                        ($"Job completed after optimizing: {count} images. Before: {totalBytesBefore / 1024} KB, after: {totalBytesAfter / 1024} KB.");
                }

                if (!PublishedStateAssessor.IsPublished(image) || image.IsDeleted)
                {
                    continue;
                }

                var imageOptimizationRequest = new ImageOptimizationRequest
                {
                    ImageUrl = image.ContentLink.GetFriendlyUrl()
                };

                ImageOptimizationResponse imageOptimizationResponse = this._imageOptimization.ProcessImage(imageOptimizationRequest);

                Identity logEntryId = this.AddLogEntry(imageOptimizationResponse, image);

                if (imageOptimizationResponse.Successful)
                {
                    totalBytesBefore += imageOptimizationResponse.OriginalImageSize;

                    if (imageOptimizationResponse.OptimizedImageSize > 0)
                    {
                        totalBytesAfter += imageOptimizationResponse.OptimizedImageSize;
                    }
                    else
                    {
                        totalBytesAfter += imageOptimizationResponse.OriginalImageSize;
                    }

                    if (image.CreateWritableClone() is ImageData file)
                    {
                        byte[] fileContent = imageOptimizationResponse.OptimizedImage;

                        var blob = blobFactory.CreateBlob(file.BinaryDataContainer, MimeTypeHelper.GetDefaultExtension(file.MimeType));

                        blob.Write(new MemoryStream(fileContent));

                        file.BinaryData = blob;

                        contentRepository.Save(file, SaveAction.Publish, AccessLevel.NoAccess);

                        this.UpdateLogEntryToOptimized(logEntryId);

                        count++;
                    }
                }
                else
                {
                    _logger.Error("ErrorMessage from SmushItProxy: " + imageOptimizationResponse.ErrorMessage);
                }
            }

            return
                ($"Job completed after optimizing: {count} images. Before: {totalBytesBefore / 1024} KB, after: {totalBytesAfter / 1024} KB.");
        }