コード例 #1
0
        public PreCacheDocumentResponse PreCacheDocument(PreCacheDocumentRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            string passToCheck = ServiceHelper.GetSettingValue(ServiceHelper.Key_Access_Passcode);

            if (!string.IsNullOrWhiteSpace(passToCheck) && request.Passcode != passToCheck)
            {
                throw new ServiceException("Document cannot be pre-cached - passcode is incorrect", HttpStatusCode.Unauthorized);
            }

            if (request.Uri == null)
            {
                throw new ArgumentException("uri must be specified");
            }

            ServiceHelper.CheckUriScheme(request.Uri);

            if (!PreCacheHelper.PreCacheExists)
            {
                // Return an empty item
                return(new PreCacheDocumentResponse());
            }

            var cache = ServiceHelper.Cache;

            // Get the cache options, if none, use All (means if the user did not pass a value, we will cache everything in the document)
            if (request.CacheOptions == DocumentCacheOptions.None)
            {
                request.CacheOptions = DocumentCacheOptions.All;
            }

            return(PreCacheHelper.AddDocument(cache, request));
        }
コード例 #2
0
        public ReportPreCacheResponse ReportPreCache([FromUri] ReportPreCacheRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            string passToCheck = ServiceHelper.GetSettingValue(ServiceHelper.Key_Access_Passcode);

            if (!string.IsNullOrWhiteSpace(passToCheck) && request.Passcode != passToCheck)
            {
                throw new ServiceException("Pre-cache cannot be reported - passcode is incorrect", HttpStatusCode.Unauthorized);
            }

            if (!PreCacheHelper.PreCacheExists)
            {
                // Return an empty report
                return(new ReportPreCacheResponse());
            }

            var cache = ServiceHelper.Cache;

            return(PreCacheHelper.ReportDocuments(cache, request.Clean));
        }
コード例 #3
0
        [HttpPost, HttpGet] // Support GET only for testing
        public LoadFromUriResponse LoadFromUri(LoadFromUriRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (request.Uri == null)
            {
                throw new ArgumentException("uri must be specified");
            }

            ServiceHelper.CheckUriScheme(request.Uri);
            if (request.Options != null && request.Options.AnnotationsUri != null)
            {
                ServiceHelper.CheckUriScheme(request.Options.AnnotationsUri);
            }

            if (request.Resolution < 0)
            {
                throw new ArgumentException("Resolution must be a value greater than or equal to zero");
            }

            var cache = ServiceHelper.Cache;

            var loadOptions = new LoadDocumentOptions();

            loadOptions.Cache       = cache;
            loadOptions.UseCache    = cache != null;
            loadOptions.CachePolicy = ServiceHelper.CreatePolicy();
            loadOptions.WebClient   = null; // Use default

            if (request.Options != null)
            {
                loadOptions.DocumentId              = request.Options.DocumentId;
                loadOptions.AnnotationsUri          = request.Options.AnnotationsUri;
                loadOptions.Name                    = request.Options.Name;
                loadOptions.Password                = request.Options.Password;
                loadOptions.LoadEmbeddedAnnotations = request.Options.LoadEmbeddedAnnotations;
                loadOptions.MaximumImagePixelSize   = request.Options.MaximumImagePixelSize;
                loadOptions.FirstPageNumber         = request.Options.FirstPageNumber;
                loadOptions.LastPageNumber          = request.Options.LastPageNumber;
            }

            // Get the document name
            var documentName = request.Uri.ToString();

            // Check if this document was uploaded, then hope the user has set LoadDocumentOptions.Name to the original file name
            if (DocumentFactory.IsUploadDocumentUri(request.Uri) && !string.IsNullOrEmpty(loadOptions.Name))
            {
                // Use that instead
                documentName = loadOptions.Name;
            }

            // Most image file formats have a signature that can be used to detect to detect the type of the file.
            // However, some formats supported by LEADTOOLS do not, such as plain text files (TXT) or DXF CAD format or
            // For these, we detect the MIME type from the file extension if available and set it in the load document options and the
            // documents library will use this value if it fails to detect the file format from the data.

            if (!string.IsNullOrEmpty(documentName))
            {
                loadOptions.MimeType = RasterCodecs.GetExtensionMimeType(documentName);
            }

            LEADDocument document = null;

            try
            {
                // first, check if this is pre-cached
                if (PreCacheHelper.PreCacheExists)
                {
                    string documentId = PreCacheHelper.CheckDocument(request.Uri, loadOptions.MaximumImagePixelSize);
                    if (documentId != null)
                    {
                        var precachedDocument = DocumentFactory.LoadFromCache(cache, documentId);
                        // Instead of returning the same pre-cached document, we'll return a cloned version.
                        // This allows the user to make changes (get/set annotations) without affecting the pre-cached version.
                        document = precachedDocument.Clone(cache, new CloneDocumentOptions()
                        {
                            CachePolicy = ServiceHelper.CreatePolicy()
                        });
                    }
                }

                // else, load normally
                if (document == null)
                {
                    document = DocumentFactory.LoadFromUri(request.Uri, loadOptions);
                    if (document == null)
                    {
                        // This document was rejected due to its mimeType.
                        throw new InvalidOperationException("Document at URI '" + request.Uri + "' uses a blocked mimeType");
                    }
                }

                CacheController.TrySetCacheUri(document);

                if (ServiceHelper.AutoUpdateHistory)
                {
                    document.History.AutoUpdate = true;
                }

                ServiceHelper.SetRasterCodecsOptions(document.RasterCodecs, request.Resolution);
                document.AutoDeleteFromCache  = false;
                document.AutoDisposeDocuments = true;
                document.AutoSaveToCache      = false;
                document.SaveToCache();

                /*
                 * NOTE: Use the line below to add this new document
                 * to the pre-cache. By doing so, everyone loading a document from
                 * that URL will get a copy of the same document from the cache/pre-cache.
                 *
                 * if (!isInPrecache)
                 *  PreCacheHelper.AddExistingDocument(request.Uri, document);
                 */
                return(new LoadFromUriResponse {
                    Document = document
                });
            }
            finally
            {
                if (document != null)
                {
                    document.Dispose();
                }
            }
        }