Esempio n. 1
0
        public async Task <BlobContent> ReadBlobContentAsync(long tenantId, long elementId, long blobSetId, string blobLabel)
        {
            HtmlElementSettings settings = await _elementRepository.ReadElementSettingsAsync(tenantId, elementId);

            if (settings == null)
            {
                return(null);
            }

            HtmlBlobSet blobSet = settings.BlobSets.Where(s => s.BlobSetId == blobSetId).FirstOrDefault();

            if (blobSet == null)
            {
                return(null);
            }

            long?blobId = GetBlobId(blobSet, blobLabel);

            if (blobId == null)
            {
                return(null);
            }

            return(await _storageService.ReadBlobContentAsync(tenantId, blobId.Value, GetHtmlImagePath(elementId)));
        }
Esempio n. 2
0
        public async Task UpdateElementSettingsAsync(long tenantId, long elementId, HtmlElementSettings settings)
        {
            // Ensure properties supplied are in the correct format
            settings.Html = (settings.Html ?? string.Empty).Trim();

            // Do the update
            await((IHtmlElementRepository)_elementRepository).UpdateElementSettingsAsync(tenantId, elementId, settings);
        }
Esempio n. 3
0
        public async Task UpdateElementSettingsAsync(long tenantId, long elementId, HtmlElementSettings settings)
        {
            // Get current element settings
            HtmlElementSettings currentSettings = await _elementRepository.ReadElementSettingsAsync(tenantId, elementId);

            // Ensure properties supplied are in the correct format
            settings.Html = (settings.Html ?? string.Empty).Trim();

            // Get uncommitted blob sets from HTML in the format...
            // <img data-image-blob-id="2455" data-preview-image-blob-id="2456" data-thumbnail-image-blob-id="2457" src="/api/v1/storage/blobs/2456/content" />
            IEnumerable <string>      newImgBlocks = _stringUtilities.ListBlocks(settings.Html, "<img ", ">");
            IEnumerable <HtmlBlobSet> newBlobSets  = newImgBlocks.Select(img => GetHtmlBlobSet(img)).Where(bs => bs != null);

            // Get existing blob sets from HTML in the format...
            // <img src="/elementtypes/c92ee4c4-b133-44cc-8322-640e99c334dc/elements/789/blobsets/418/content" width="1200" height="900" alt="IMG_20180622_141721.jpg" />
            IEnumerable <string> currentImgBlocks  = _stringUtilities.ListBlocks(settings.Html, "<img src=\"/elementtypes/", ">");
            IEnumerable <long>   currentBlobSetIds = currentImgBlocks.Select(img => GetBlobSetId(img)).Where(id => id != 0);

            // Update blob sets so collection includes current blob sets and new blob sets
            settings.BlobSets = currentSettings.BlobSets.Where(b => currentBlobSetIds.Contains(b.BlobSetId)).Concat(newBlobSets);

            // Get blob sets that are no longer included
            IEnumerable <HtmlBlobSet> oldBlobSets = currentSettings.BlobSets.Where(b => !currentBlobSetIds.Contains(b.BlobSetId));

            // Commit new blobs
            foreach (HtmlBlobSet blobSet in newBlobSets)
            {
                await _storageService.CommitBlobAsync(tenantId, blobSet.ImageBlobId, GetHtmlImagePath(elementId));

                await _storageService.CommitBlobAsync(tenantId, blobSet.PreviewImageBlobId, GetHtmlImagePath(elementId));

                await _storageService.CommitBlobAsync(tenantId, blobSet.ThumbnailImageBlobId, GetHtmlImagePath(elementId));
            }

            // Do the update
            await((IHtmlElementRepository)_elementRepository).UpdateElementSettingsAsync(tenantId, elementId, settings);

            // Delete old blobs
            foreach (HtmlBlobSet blobSet in oldBlobSets)
            {
                await _storageService.DeleteBlobAsync(tenantId, blobSet.ThumbnailImageBlobId, GetHtmlImagePath(elementId));

                await _storageService.DeleteBlobAsync(tenantId, blobSet.PreviewImageBlobId, GetHtmlImagePath(elementId));

                await _storageService.DeleteBlobAsync(tenantId, blobSet.ImageBlobId, GetHtmlImagePath(elementId));
            }

            // Update HTML so that links to uncommited images become links to committed images
            HtmlElementSettings newSettings = await _elementRepository.ReadElementSettingsAsync(tenantId, elementId);

            IDictionary <long, HtmlPreviewImage> previewImagesByHtmlBlobId = await GetPreviewImagesByHtmlBlobId(tenantId, newSettings);

            IDictionary <long, long> blobSetIdsByPreviewImageBlobId = newSettings.BlobSets.ToDictionary(bs => bs.PreviewImageBlobId, bs => bs.BlobSetId);
            HtmlTransformer          transformer = new HtmlTransformer(elementId, previewImagesByHtmlBlobId, blobSetIdsByPreviewImageBlobId, _stringUtilities);

            newSettings.Html = _stringUtilities.BlockReplace(newSettings.Html, "<img ", ">", transformer.EnsureCommittedUrl);
            await((IHtmlElementRepository)_elementRepository).UpdateElementSettingsAsync(tenantId, elementId, newSettings);
        }
Esempio n. 4
0
        public async Task <HtmlElementContent> ReadElementContentAsync(long tenantId, long elementId, long pageId)
        {
            HtmlElementSettings elementSettings = await _elementRepository.ReadElementSettingsAsync(tenantId, elementId);

            return(new HtmlElementContent
            {
                FormattedHtml = FormatHtml(elementSettings.Html)
            });
        }
Esempio n. 5
0
        private async Task <HtmlElementSettings> GetElementSettingsAsync(long tenantId, long elementId)
        {
            // Get element settings
            HtmlElementSettings settings = await _elementRepository.ReadElementSettingsAsync(tenantId, elementId);

            if (settings == null)
            {
                return(null);
            }

            // Convert old format URLs into new format URLs
            IDictionary <long, HtmlPreviewImage> previewImagesByHtmlBlobId = await GetPreviewImagesByHtmlBlobId(tenantId, settings);

            HtmlTransformer transformer = new HtmlTransformer(elementId, previewImagesByHtmlBlobId, null, _stringUtilities);

            settings.Html = ReplaceKeywords(settings.Html);
            settings.Html = _stringUtilities.BlockReplace(settings.Html, "<img src=\"/elements/", ">", transformer.TransformUrl);
            settings.Html = _stringUtilities.BlockReplace(settings.Html, "<img src=\"/elementtypes/", ">", transformer.CheckUrl);

            // Return the result
            return(settings);
        }
Esempio n. 6
0
        public async Task <IElementView <HtmlElementSettings, HtmlElementContent> > ReadElementViewAsync(long tenantId, long elementId, IPageContext context)
        {
            // Get element settings
            HtmlElementSettings settings = await _elementRepository.ReadElementSettingsAsync(tenantId, elementId);

            if (settings == null)
            {
                return(null);
            }

            // Get details of all preview images that may be displayed in the HTML content
            IEnumerable <long> blobIds = settings.BlobSets.Select(s => s.PreviewImageBlobId);
            IEnumerable <Blob> blobs   = await _storageService.ListBlobsAsync(tenantId, blobIds);

            IDictionary <long, BlobImage> blobsById = blobs.ToDictionary(b => b.BlobId, b => (BlobImage)b);

            // Construct dictionary containing details of all preview images keyed by blob set identifier
            IDictionary <long, HtmlPreviewImage> previewImagesByHtmlBlobId = settings.BlobSets
                                                                             .Where(s => blobsById.ContainsKey(s.PreviewImageBlobId))
                                                                             .Select(s => GetHtmlPreviewImageFromHtmlBlob(s, blobsById))
                                                                             .ToDictionary(i => i.BlobSetId, i => i);

            // Format HTML
            string formattedHtml = FormatHtml(settings.Html, previewImagesByHtmlBlobId);

            // Construct element content
            HtmlElementContent content = new HtmlElementContent
            {
                FormattedHtml = formattedHtml,
                Images        = previewImagesByHtmlBlobId
            };

            // Return element view
            return(new ElementView <HtmlElementSettings, HtmlElementContent>
            {
                Settings = settings,
                Content = content
            });
        }
Esempio n. 7
0
        public async Task <IElementView <HtmlElementSettings, HtmlElementContent> > ReadElementViewAsync(long tenantId, long elementId, IPageContext context)
        {
            // Get element settings
            HtmlElementSettings settings = await GetElementSettingsAsync(tenantId, elementId);

            if (settings == null)
            {
                return(null);
            }

            // Construct element content
            HtmlElementContent content = new HtmlElementContent
            {
                FormattedHtml = settings.Html,
                Images        = null// previewImagesByHtmlBlobId
            };

            // Return element view
            return(new ElementView <HtmlElementSettings, HtmlElementContent>
            {
                Settings = settings,
                Content = content
            });
        }
Esempio n. 8
0
        private async Task <IDictionary <long, HtmlPreviewImage> > GetPreviewImagesByHtmlBlobId(long tenantId, HtmlElementSettings settings)
        {
            // Get details of all preview images that may be displayed in the HTML content
            IEnumerable <long> blobIds = settings.BlobSets.Select(s => s.PreviewImageBlobId);
            IEnumerable <Blob> blobs   = await _storageService.ListBlobsAsync(tenantId, blobIds);

            IDictionary <long, BlobImage> blobsById = blobs.ToDictionary(b => b.BlobId, b => (BlobImage)b);

            // Construct dictionary containing details of all preview images keyed by blob set identifier
            IDictionary <long, HtmlPreviewImage> previewImagesByHtmlBlobId = settings.BlobSets
                                                                             .Where(s => blobsById.ContainsKey(s.PreviewImageBlobId))
                                                                             .Select(s => GetHtmlPreviewImageFromHtmlBlob(s, blobsById))
                                                                             .ToDictionary(i => i.BlobSetId, i => i);

            return(previewImagesByHtmlBlobId);
        }