public void SaveDescription(DocumentInfoContainer description) { if(description == null) return; string descriptionFolder = Path.Combine(repoPath, description.Name, description.DocumentType); lock (_syncRoot) { if(!Directory.Exists(descriptionFolder)) Directory.CreateDirectory(descriptionFolder); try { using(var stream = File.OpenWrite(Path.Combine(descriptionFolder, "fd.json"))) using(var writer = new StreamWriter(stream)) using(JsonWriter jwriter = new JsonTextWriter(writer) { Formatting = Formatting.Indented }) { JsonSerializer serializer = new JsonSerializer(); serializer.Serialize(jwriter, description); } } catch(Exception e) { throw new Exception("Failed to serialize an object to file: '{0}'.", e); } } }
public ActionResult Index(string file, string attachment, int page, string resource) { var attachmentPath = "cache\\" + Path.GetFileNameWithoutExtension(file) + Path.GetExtension(file).Replace(".", "_") + "\\attachments\\" + attachment; ViewerHtmlHandler handler = Utils.CreateViewerHtmlHandler(); DocumentInfoContainer info = handler.GetDocumentInfo(file); List <int> pageNumberstoRender = new List <int>(); pageNumberstoRender.Add(page); HtmlOptions o = new HtmlOptions(); int pageNumber = page; o.PageNumbersToRender = pageNumberstoRender; o.PageNumber = page; o.CountPagesToRender = 1; List <PageHtml> pages = handler.GetPages(attachmentPath, o); List <HtmlResource> htmlResources = pages.Where(x => x.PageNumber == page).Select(x => x.HtmlResources).FirstOrDefault(); var fileResource = htmlResources.Where(x => x.ResourceName == resource).FirstOrDefault(); string type = ""; if (fileResource != null) { switch (fileResource.ResourceType) { case HtmlResourceType.Font: type = "application/font-woff"; break; case HtmlResourceType.Style: type = "text/css"; break; case HtmlResourceType.Image: type = "image/jpeg"; break; case HtmlResourceType.Graphics: type = "image/svg+xml"; break; } Stream stream = handler.GetResource(attachmentPath, fileResource); return(new FileStreamResult(stream, type)); } return(null); }
public HttpResponseMessage Get(string file, string attachment, int page, string resource) { var attachmentPath = "cache\\" + Path.GetFileNameWithoutExtension(file) + Path.GetExtension(file).Replace(".", "_") + "\\attachments\\" + attachment; ViewerHtmlHandler handler = Utils.CreateViewerHtmlHandler(); DocumentInfoContainer info = handler.GetDocumentInfo(file); List <int> pageNumberstoRender = new List <int>(); pageNumberstoRender.Add(page); HtmlOptions o = new HtmlOptions(); int pageNumber = page; o.PageNumbersToRender = pageNumberstoRender; o.PageNumber = page; o.CountPagesToRender = 1; List <PageHtml> pages = handler.GetPages(attachmentPath, o); List <HtmlResource> htmlResources = pages.Where(x => x.PageNumber == page).Select(x => x.HtmlResources).FirstOrDefault(); var fileResource = htmlResources.Where(x => x.ResourceName == resource).FirstOrDefault(); string type = ""; if (fileResource != null) { switch ((int)fileResource.ResourceType) { case 2: type = "application/font-woff"; break; case 3: type = "text/css"; break; case 1: type = "image/jpeg"; break; } Stream stream = handler.GetResource(attachmentPath, fileResource); var result = new HttpResponseMessage(HttpStatusCode.OK); result.Content = new StreamContent(stream); result.Content.Headers.ContentType = new MediaTypeHeaderValue(type); return(result); } return(null); }
public HttpResponseMessage Get(int?width, string file, string attachment, int page, string watermarkText, int?watermarkColor, WatermarkPosition?watermarkPosition, int?watermarkWidth, byte watermarkOpacity, int?height = null) { ViewerImageHandler handler = Utils.CreateViewerImageHandler(); ImageOptions o = new ImageOptions(); List <int> pageNumberstoRender = new List <int>(); pageNumberstoRender.Add(page); o.PageNumbersToRender = pageNumberstoRender; o.PageNumber = page; o.CountPagesToRender = 1; if (width.HasValue) { o.Width = Convert.ToInt32(width); } if (height.HasValue) { o.Height = Convert.ToInt32(height); } if (watermarkText != "") { o.Watermark = Utils.GetWatermark(watermarkText, watermarkColor, watermarkPosition, watermarkWidth, watermarkOpacity); } Stream stream = null; DocumentInfoContainer info = handler.GetDocumentInfo(file); // Iterate over the attachments collection foreach (AttachmentBase attachmentBase in info.Attachments.Where(x => x.Name == attachment)) { List <PageImage> pages = handler.GetPages(attachmentBase, o); foreach (PageImage attachmentPage in pages.Where(x => x.PageNumber == page)) { stream = attachmentPage.Stream; } ; } var result = new HttpResponseMessage(HttpStatusCode.OK); Image image = Image.FromStream(stream); MemoryStream memoryStream = new MemoryStream(); image.Save(memoryStream, ImageFormat.Jpeg); result.Content = new ByteArrayContent(memoryStream.ToArray()); result.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg"); return(result); }
public ActionResult RotatePage(RotatePageParameters parameters) { string guid = parameters.Path; int pageIndex = parameters.PageNumber; DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(guid); int pageNumber = documentInfoContainer.Pages[pageIndex].Number; RotatePageOptions rotatePageOptions = new RotatePageOptions(pageNumber, parameters.RotationAmount); _imageHandler.RotatePage(guid, rotatePageOptions); documentInfoContainer = _imageHandler.GetDocumentInfo(guid); var resultAngle = documentInfoContainer.Pages[pageIndex].Angle; return(ToJsonResult(new RotatePageResponse { resultAngle = resultAngle })); }
public static RotatePageResponse RotatePage(RotatePageParameters parameters) { string guid = parameters.Path; int pageIndex = parameters.PageNumber; DocumentInfoOptions documentInfoOptions = new DocumentInfoOptions(guid); DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(documentInfoOptions); int pageNumber = documentInfoContainer.Pages[pageIndex].Number; RotatePageOptions rotatePageOptions = new RotatePageOptions(guid, pageNumber, parameters.RotationAmount); RotatePageContainer rotatePageContainer = _imageHandler.RotatePage(rotatePageOptions); RotatePageResponse response = new RotatePageResponse { resultAngle = rotatePageContainer.CurrentRotationAngle }; return(response); }
private static void ViewDocumentAsImage(ViewDocumentParameters request, ViewDocumentResponse result, string fileName) { var docInfo = _imageHandler.GetDocumentInfo(new DocumentInfoOptions(request.Path)); var maxWidth = 0; var maxHeight = 0; foreach (var pageData in docInfo.Pages) { if (pageData.Height > maxHeight) { maxHeight = pageData.Height; maxWidth = pageData.Width; } } var fileData = new FileData { DateCreated = DateTime.Now, DateModified = docInfo.LastModificationDate, PageCount = docInfo.Pages.Count, Pages = docInfo.Pages, MaxWidth = maxWidth, MaxHeight = maxHeight }; result.documentDescription = new FileDataJsonSerializer(fileData, new FileDataOptions()).Serialize(true); result.docType = docInfo.DocumentType; result.fileType = docInfo.FileType; DocumentInfoOptions documentInfoOptions = new DocumentInfoOptions(request.Path); DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(documentInfoOptions); int[] pageNumbers = new int[documentInfoContainer.Pages.Count]; for (int i = 0; i < documentInfoContainer.Pages.Count; i++) { pageNumbers[i] = documentInfoContainer.Pages[i].Number; } string applicationHost = GetApplicationHost(); result.imageUrls = ImageUrlHelper.GetImageUrls(applicationHost, pageNumbers, request); }
/// <summary> /// Get attached file's html representation /// </summary> /// <param name="DocumentName">Input document name</param> public static void GetEmailAttachmentHTMLRepresentation(String DocumentName) { try { //ExStart:GetEmailAttachmentHTMLRepresentation // Setup GroupDocs.Viewer config ViewerConfig config = Utilities.GetConfigurations(); // Setup html conversion options HtmlOptions htmlOptions = new HtmlOptions(); htmlOptions.IsResourcesEmbedded = false; // Init viewer html handler ViewerHtmlHandler handler = new ViewerHtmlHandler(config); DocumentInfoContainer info = handler.GetDocumentInfo(DocumentName); // Iterate over the attachments collection foreach (AttachmentBase attachment in info.Attachments) { Console.WriteLine("Attach name: {0}, size: {1}", attachment.Name, attachment.FileType); // Get attachment document html representation List <PageHtml> pages = handler.GetPages(attachment, htmlOptions); foreach (PageHtml page in pages) { Console.WriteLine(" Page: {0}, size: {1}", page.PageNumber, page.HtmlContent.Length); foreach (HtmlResource htmlResource in page.HtmlResources) { Stream resourceStream = handler.GetResource(attachment, htmlResource); Console.WriteLine(" Resource: {0}, size: {1}", htmlResource.ResourceName, resourceStream.Length); } } } //ExEnd:GetEmailAttachmentHTMLRepresentation } catch (System.Exception exp) { Console.WriteLine(exp.Message); } }
/// <summary> /// Get document information by stream /// </summary> /// <param name="DocumentName">Name of input document</param> public static void GetDocumentInfoByStream(String DocumentName) { try { //ExStart:GetDocumentInfoByStream // Setup GroupDocs.Viewer config ViewerConfig config = Utilities.GetConfigurations(); // Create html handler ViewerHtmlHandler htmlHandler = new ViewerHtmlHandler(config); // Get document stream Stream stream = Utilities.GetDocumentStream(DocumentName); // Get document information DocumentInfoOptions options = new DocumentInfoOptions(); DocumentInfoContainer documentInfo = htmlHandler.GetDocumentInfo(stream, options); Console.WriteLine("DateCreated: {0}", documentInfo.DateCreated); Console.WriteLine("DocumentType: {0}", documentInfo.DocumentType); Console.WriteLine("DocumentTypeFormat: {0}", documentInfo.DocumentTypeFormat); Console.WriteLine("Extension: {0}", documentInfo.Extension); Console.WriteLine("FileType: {0}", documentInfo.FileType); Console.WriteLine("Guid: {0}", documentInfo.Guid); Console.WriteLine("LastModificationDate: {0}", documentInfo.LastModificationDate); Console.WriteLine("Name: {0}", documentInfo.Name); Console.WriteLine("PageCount: {0}", documentInfo.Pages.Count); Console.WriteLine("Size: {0}", documentInfo.Size); foreach (PageData pageData in documentInfo.Pages) { Console.WriteLine("Page number: {0}", pageData.Number); Console.WriteLine("Page name: {0}", pageData.Name); } stream.Close(); //ExEnd:GetDocumentInfoByStream } catch (System.Exception exp) { Console.WriteLine(exp.Message); } }
public ActionResult Get(string file) { if (Utils.IsValidUrl(file)) { file = Utils.DownloadToStorage(file); } ViewerHtmlHandler handler = Utils.CreateViewerHtmlHandler(); DocumentInfoContainer info = null; ResultModel model = new ResultModel(); DocumentInfoOptions options = new DocumentInfoOptions(file); try { info = handler.GetDocumentInfo(file, options); } catch (Exception x) { throw x; } model.pages = info.Pages; List <Attachment> attachmentList = new List <Attachment>(); foreach (AttachmentBase attachment in info.Attachments) { List <int> count = new List <int>(); List <PageHtml> pages = handler.GetPages(attachment); for (int i = 1; i <= pages.Count; i++) { count.Add(i); } model.attachments.Add(new Attachment(attachment.Name, count)); } return(Content(JsonConvert.SerializeObject( model, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() } ), "application/json")); }
public static RotatePageResponse RotatePage(RotatePageParameters parameters) { string guid = parameters.Path; int pageIndex = parameters.PageNumber; DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(guid); int pageNumber = documentInfoContainer.Pages[pageIndex].Number; RotatePageOptions rotatePageOptions = new RotatePageOptions(pageNumber, parameters.RotationAmount); _imageHandler.RotatePage(guid, rotatePageOptions); DocumentInfoContainer container = _imageHandler.GetDocumentInfo(guid); PageData pageData = container.Pages.Single(_ => _.Number == pageNumber); RotatePageResponse response = new RotatePageResponse { resultAngle = pageData.Angle }; return(response); }
public ActionResult ReorderPage(ReorderPageParameters parameters) { try { string guid = parameters.Path; DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(guid); int pageNumber = documentInfoContainer.Pages[parameters.OldPosition].Number; int newPosition = parameters.NewPosition + 1; ReorderPageOptions reorderPageOptions = new ReorderPageOptions(pageNumber, newPosition); _imageHandler.ReorderPage(guid, reorderPageOptions); return(ToJsonResult(new ReorderPageResponse())); } catch (Exception e) { return(this.JsonOrJsonP(new FailedResponse { Reason = e.Message }, null)); } }
public ActionResult Get(int?width, int?height, string file, string attachment, int page, string watermarkText, int?watermarkColor, WatermarkPosition?watermarkPosition, int?watermarkWidth, byte watermarkOpacity) { ViewerImageHandler handler = Utils.CreateViewerImageHandler(); ImageOptions o = new ImageOptions(); List <int> pageNumberstoRender = new List <int>(); pageNumberstoRender.Add(page); o.PageNumbersToRender = pageNumberstoRender; o.PageNumber = page; o.CountPagesToRender = 1; if (watermarkText != "") { o.Watermark = Utils.GetWatermark(watermarkText, watermarkColor, watermarkPosition, watermarkWidth, watermarkOpacity); } if (width.HasValue) { o.Width = Convert.ToInt32(width); } if (height.HasValue) { o.Height = Convert.ToInt32(height); } Stream stream = null; DocumentInfoContainer info = handler.GetDocumentInfo(file); // Iterate over the attachments collection foreach (AttachmentBase attachmentBase in info.Attachments.Where(x => x.Name == attachment)) { List <PageImage> pages = handler.GetPages(attachmentBase, o); foreach (PageImage attachmentPage in pages.Where(x => x.PageNumber == page)) { stream = attachmentPage.Stream; } ; } return(new FileStreamResult(stream, "image/png")); }
public List <PageDataModel> Get(string file) { ViewerHtmlHandler handler = Utils.CreateViewerHtmlHandler(); DocumentInfoContainer info = null; try { info = handler.GetDocumentInfo(file); } catch (Exception x) { throw x; } List <PageData> result = new List <PageData>(); foreach (PageData pageData in info.Pages) { result.Add(pageData); } return(Convert(result)); }
public HttpResponseMessage LoadDocumentDescription(PostedDataWrapper postedData) { string password = ""; string documentGuid = ""; bool htmlMode = false; try { // get request body if (postedData != null) { // get/set parameters documentGuid = postedData.guid; htmlMode = postedData.htmlMode; password = postedData.password; // check if documentGuid contains path or only file name if (!Path.IsPathRooted(documentGuid)) { documentGuid = quickViewConfig.getApplication().getFilesDirectory() + "/" + documentGuid; } } DocumentInfoContainer documentInfoContainer = new DocumentInfoContainer(); // get document info options DocumentInfoOptions documentInfoOptions = new DocumentInfoOptions(documentGuid); // set password for protected document documentInfoOptions.Password = password; // get document info container if (htmlMode) { documentInfoContainer = viewerHtmlHandler.GetDocumentInfo(documentGuid, documentInfoOptions); } else { documentInfoContainer = viewerImageHandler.GetDocumentInfo(documentGuid, documentInfoOptions); } // return document description return(Request.CreateResponse(HttpStatusCode.OK, documentInfoContainer.Pages)); } catch (InvalidPasswordException ex) { // Set exception message ErrorMsgWrapper errorMsgWrapper = new ErrorMsgWrapper(); if (String.IsNullOrEmpty(password)) { errorMsgWrapper.message = "Password Required"; } else if (!String.IsNullOrEmpty(password)) { errorMsgWrapper.message = "Incorrect password"; } else { errorMsgWrapper.message = ex.Message; } errorMsgWrapper.exception = ex; return(Request.CreateResponse(HttpStatusCode.OK, errorMsgWrapper)); } catch (Exception ex) { // set exception message ErrorMsgWrapper errorMsgWrapper = new ErrorMsgWrapper(); errorMsgWrapper.message = ex.Message; errorMsgWrapper.exception = ex; return(Request.CreateResponse(HttpStatusCode.OK, errorMsgWrapper)); } }
public static GetImageUrlsResponse GetImageUrls(GetImageUrlsParameters parameters) { var docPath = parameters.Path; if (string.IsNullOrEmpty(parameters.Path)) { var empty = new GetImageUrlsResponse { imageUrls = new string[0] }; return(empty); } DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(parameters.Path); int[] pageNumbers = new int[documentInfoContainer.Pages.Count]; for (int i = 0; i < documentInfoContainer.Pages.Count; i++) { pageNumbers[i] = documentInfoContainer.Pages[i].Number; } var applicationHost = GetApplicationHost(); string[] imageUrls = ImageUrlHelper.GetImageUrls(applicationHost, pageNumbers, parameters); string[] attachmentUrls = new string[0]; foreach (AttachmentBase attachment in documentInfoContainer.Attachments) { List <PageImage> pages = _imageHandler.GetPages(attachment); var attachmentInfo = _imageHandler.GetDocumentInfo(_tempPath + "\\" + Path.GetFileNameWithoutExtension(docPath) + Path.GetExtension(docPath).Replace(".", "_") + "\\attachments\\" + attachment.Name); GetImageUrlsParameters attachmentResponse = parameters; attachmentResponse.Path = attachmentInfo.Guid; int[] attachmentPageNumbers = new int[pages.Count]; for (int i = 0; i < pages.Count; i++) { attachmentPageNumbers[i] = pages[i].PageNumber; } Array.Resize <string>(ref attachmentUrls, (attachmentUrls.Length + pages.Count)); string[] attachmentImagesUrls = new string[pages.Count]; attachmentImagesUrls = ImageUrlHelper.GetImageUrls(applicationHost, attachmentPageNumbers, attachmentResponse); attachmentImagesUrls.CopyTo(attachmentUrls, (attachmentUrls.Length - pages.Count)); } if (documentInfoContainer.Attachments.Count > 0) { var imagesUrls = new string[attachmentUrls.Length + imageUrls.Length]; imageUrls.CopyTo(imagesUrls, 0); attachmentUrls.CopyTo(imagesUrls, imageUrls.Length); var result = new GetImageUrlsResponse { imageUrls = imagesUrls }; return(result); } else { var result = new GetImageUrlsResponse { imageUrls = imageUrls }; return(result); } }
public ActionResult GetDocumentPageImage(GetDocumentPageImageParameters parameters) { var guid = parameters.Path; var pageIndex = parameters.PageIndex; var pageNumber = pageIndex + 1; var imageOptions = new ImageOptions { //ConvertImageFileType = _convertImageFileType, /*Watermark = Utils.GetWatermark(parameters.WatermarkText, parameters.WatermarkColor, * parameters.WatermarkPosition, parameters.WatermarkWidth),*/ //Transformations = parameters.Rotate ? Transformation.Rotate : Transformation.None, PageNumbersToConvert = new List <int>() { parameters.PageIndex }, PageNumber = pageNumber, //JpegQuality = parameters.Quality.GetValueOrDefault() }; DocumentInfoContainer documentInfoContainer = annotator.GetDocumentInfo(guid); if (parameters.Rotate && parameters.Width.HasValue) { int pageAngle = documentInfoContainer.Pages[pageIndex].Angle; var isHorizontalView = pageAngle == 90 || pageAngle == 270; int sideLength = parameters.Width.Value; if (isHorizontalView) { imageOptions.Height = sideLength; } else { imageOptions.Width = sideLength; } } else if (parameters.Width.HasValue) { imageOptions.Width = parameters.Width.Value; } string baseUrl = Request.Url.Scheme + "://" + Request.Url.Authority + Request.ApplicationPath.TrimEnd('/') + "/"; // If no cache - save images to temp folder string tempFolderPath = Path.Combine(HttpContext.Server.MapPath("~"), "Content", "TempStorage"); PageImage pageImage; string docFoldePath = Path.Combine(tempFolderPath, parameters.Path); if (!Directory.Exists(docFoldePath)) { Directory.CreateDirectory(docFoldePath); } string pageImageName = string.Format("{0}\\{1}.png", docFoldePath, pageIndex); if (!System.IO.File.Exists(pageImageName)) { pageImage = annotator.GetPages(guid, imageOptions).Single(); using (FileStream fileStream = new FileStream(pageImageName, FileMode.Create)) { pageImage.Stream.Seek(0, SeekOrigin.Begin); pageImage.Stream.CopyTo(fileStream); } pageImage.Stream.Position = 0; return(File(pageImage.Stream, String.Format("image/{0}", "png"))); } Stream stream = new MemoryStream(); using (FileStream fsSource = new FileStream(pageImageName, FileMode.Open, FileAccess.Read)) { fsSource.Seek(0, SeekOrigin.Begin); fsSource.CopyTo(stream); } stream.Position = 0; return(File(stream, "image/png")); }
public static ViewDocumentResponse ViewDocument(string path) { string request = path; try { GroupDocs.Annotation.License lic = new GroupDocs.Annotation.License(); lic.SetLicense("C:/Users/Ali Ahmad/Documents/GroupDocs.Total.lic"); } catch (Exception ex) { throw; } string fileName = Path.GetFileName(request); var pathFinder = new ApplicationPathFinder(); string _appPath = HttpContext.Current.Server.MapPath("~/_layouts/15/GroupDocs_Annotation_SharePoint_WebPart/"); ViewDocumentResponse result = new ViewDocumentResponse { pageCss = new string[] { }, lic = true, pdfDownloadUrl = _appPath + "App_Data/" + request, url = _appPath + "App_Data/" + request, path = request, name = fileName }; DocumentInfoContainer docInfo = null; try { docInfo = annotator.GetDocumentInfo(request); } catch (Exception ex) { throw; } result.documentDescription = new FileDataJsonSerializer(docInfo.Pages).Serialize(true); result.docType = docInfo.DocumentType; result.fileType = docInfo.FileType; List <PageImage> imagePages = annotator.GetPages(request); // Provide images urls List <string> urls = new List <string>(); // If no cache - save images to temp folder string tempFolderPath = HttpContext.Current.Server.MapPath("~/_layouts/15/GroupDocs_Annotation_SharePoint_WebPart/Content/TempStorage"); foreach (PageImage pageImage in imagePages) { string docFoldePath = Path.Combine(tempFolderPath, request); if (!Directory.Exists(docFoldePath)) { Directory.CreateDirectory(docFoldePath); } string pageImageName = string.Format("{0}\\{1}.png", docFoldePath, pageImage.PageNumber); using (Stream stream = pageImage.Stream) using (FileStream fileStream = new FileStream(pageImageName, FileMode.Create)) { stream.Seek(0, SeekOrigin.Begin); stream.CopyTo(fileStream); } string baseUrl = HttpContext.Current.Request.Url.Scheme + "://" + HttpContext.Current.Request.Url.Authority + HttpContext.Current.Request.ApplicationPath + "_layouts/15/GroupDocs_Annotation_SharePoint_WebPart/"; urls.Add(string.Format("{0}Content/TempStorage/{1}/{2}.png", baseUrl, request, pageImage.PageNumber)); } result.imageUrls = urls.ToArray(); // invoke event new DocumentOpenSubscriber().HandleEvent(request, _annotationSvc); return(result); }
public ActionResult Get(int?width, int?height, string file, int page, string watermarkText, int?watermarkColor, WatermarkPosition?watermarkPosition, int?watermarkWidth, byte watermarkOpacity, int?rotate, int?zoom) { if (Utils.IsValidUrl(file)) { file = Utils.DownloadToStorage(file); } ViewerImageHandler handler = Utils.CreateViewerImageHandler(); if (rotate.HasValue) { if (rotate.Value > 0) { handler.ClearCache(file); } } ImageOptions options = new ImageOptions(); options.PageNumbersToRender = new List <int>(new int[] { page }); options.PageNumber = page; options.CountPagesToRender = 1; if (Path.GetExtension(file).ToLower().StartsWith(".xls")) { options.CellsOptions.OnePagePerSheet = false; options.CellsOptions.CountRowsPerPage = 150; } if (watermarkText != "") { options.Watermark = Utils.GetWatermark(watermarkText, watermarkColor, watermarkPosition, watermarkWidth, watermarkOpacity); } if (width.HasValue) { int w = Convert.ToInt32(width); if (zoom.HasValue) { w = w + zoom.Value; } options.Width = w; } if (height.HasValue) { if (zoom.HasValue) { options.Height = options.Height + zoom.Value; } } if (rotate.HasValue) { if (rotate.Value > 0) { if (width.HasValue) { int side = options.Width; DocumentInfoContainer documentInfoContainer = handler.GetDocumentInfo(file); int pageAngle = documentInfoContainer.Pages[page - 1].Angle; if (pageAngle == 90 || pageAngle == 270) { options.Height = side; } else { options.Width = side; } } options.Transformations = Transformation.Rotate; handler.RotatePage(file, new RotatePageOptions(page, rotate.Value)); } } else { options.Transformations = Transformation.None; handler.RotatePage(file, new RotatePageOptions(page, 0)); } using (new InterProcessLock(file)) { List <PageImage> list = handler.GetPages(file, options); PageImage pageImage = list.Single(_ => _.PageNumber == page); return(File(pageImage.Stream, "image/png")); } }
/// <summary> /// Initializes a new instance of the <see cref="DocumentInfoContainer"/> class. /// </summary> /// <param name="documentInfo">The document info.</param> /// <param name="options">The options.</param> public DocumentInfoJsonSerializer(DocumentInfoContainer documentInfo, SerializationOptions options) { _documentInfo = documentInfo; _options = options; }
protected void Page_Load(object sender, EventArgs e) { var file = GetValueFromQueryString("file"); var attachment = GetValueFromQueryString("attachment"); int page = Convert.ToInt32(GetValueFromQueryString("page")); int?width = Convert.ToInt32(GetValueFromQueryString("width")); int?height = Convert.ToInt32(GetValueFromQueryString("width")); if (Utils.IsValidUrl(file)) { file = Utils.DownloadToStorage(file); } string watermarkText = GetValueFromQueryString("watermarkText"); int? watermarkColor = Convert.ToInt32(GetValueFromQueryString("watermarkColor")); WatermarkPosition watermarkPosition = (WatermarkPosition)Enum.Parse(typeof(WatermarkPosition), GetValueFromQueryString("watermarkPosition"), true); string widthFromQuery = GetValueFromQueryString("watermarkWidth"); int? watermarkWidth = GetValueFromQueryString("watermarkWidth") == "null" ? null : (int?)Convert.ToInt32(GetValueFromQueryString("watermarkWidth")); byte watermarkOpacity = Convert.ToByte(GetValueFromQueryString("watermarkOpacity")); ViewerImageHandler handler = Utils.CreateViewerImageHandler(); ImageOptions o = new ImageOptions(); List <int> pageNumberstoRender = new List <int>(); pageNumberstoRender.Add(page); o.PageNumbersToRender = pageNumberstoRender; o.PageNumber = page; o.CountPagesToRender = 1; if (width.HasValue) { o.Width = Convert.ToInt32(width); } if (height.HasValue) { o.Height = Convert.ToInt32(height); } if (watermarkText != "") { o.Watermark = Utils.GetWatermark(watermarkText, watermarkColor, watermarkPosition, watermarkWidth, watermarkOpacity); } Stream stream = null; DocumentInfoContainer info = handler.GetDocumentInfo(file); // Iterate over the attachments collection foreach (AttachmentBase attachmentBase in info.Attachments.Where(x => x.Name == attachment)) { List <PageImage> pages = handler.GetPages(attachmentBase); foreach (PageImage attachmentPage in pages.Where(x => x.PageNumber == page)) { stream = attachmentPage.Stream; } ; } var result = new HttpResponseMessage(HttpStatusCode.OK); System.Drawing.Image image = System.Drawing.Image.FromStream(stream); MemoryStream memoryStream = new MemoryStream(); image.Save(memoryStream, ImageFormat.Jpeg); HttpContext.Current.Response.ContentType = "image/jpeg"; memoryStream.WriteTo(HttpContext.Current.Response.OutputStream); HttpContext.Current.Response.Flush(); HttpContext.Current.Response.End(); }
public ActionResult ViewDocument(ViewDocumentParameters request) { string fileName = Path.GetFileName(request.Path); ViewDocumentResponse result = new ViewDocumentResponse { pageCss = new string[] { }, lic = true, pdfDownloadUrl = GetPdfDownloadUrl(request), url = GetFileUrl(request), path = request.Path, name = fileName }; DocumentInfoContainer docInfo = annotator.GetDocumentInfo(request.Path); result.documentDescription = new FileDataJsonSerializer(docInfo.Pages).Serialize(true); result.docType = docInfo.DocumentType; result.fileType = docInfo.FileType; List <PageImage> imagePages = annotator.GetPages(request.Path); // Provide images urls List <string> urls = new List <string>(); // If no cache - save images to temp folder string tempFolderPath = Path.Combine(HttpContext.Server.MapPath("~"), "Content", "TempStorage"); foreach (PageImage pageImage in imagePages) { string docFoldePath = Path.Combine(tempFolderPath, request.Path); if (!Directory.Exists(docFoldePath)) { Directory.CreateDirectory(docFoldePath); } string pageImageName = string.Format("{0}\\{1}.png", docFoldePath, pageImage.PageNumber); using (Stream stream = pageImage.Stream) using (FileStream fileStream = new FileStream(pageImageName, FileMode.Create)) { stream.Seek(0, SeekOrigin.Begin); stream.CopyTo(fileStream); } string baseUrl = Request.Url.Scheme + "://" + Request.Url.Authority + Request.ApplicationPath.TrimEnd('/') + "/"; urls.Add(string.Format("{0}Content/TempStorage/{1}/{2}.png", baseUrl, request.Path, pageImage.PageNumber)); } result.imageUrls = urls.ToArray(); JavaScriptSerializer serializer = new JavaScriptSerializer { MaxJsonLength = int.MaxValue }; string serializedData = serializer.Serialize(result); // invoke event new DocumentOpenSubscriber().HandleEvent(request.Path); return(Content(serializedData, "application/json")); }
protected void Page_Load(object sender, EventArgs e) { _config = new ViewerConfig { StoragePath = _storagePath, UseCache = true }; ViewerImageHandler imageHandler = (ViewerImageHandler)HttpContext.Current.Session["imageHandler"]; ViewerHtmlHandler htmlHandler = (ViewerHtmlHandler)HttpContext.Current.Session["htmlHandler"]; GetDocumentPageImageParameters parameters = new GetDocumentPageImageParameters(); foreach (String key in Request.QueryString.AllKeys) { if (!string.IsNullOrEmpty(Request.QueryString[key])) { var propertyInfo = parameters.GetType().GetProperty(key, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance); propertyInfo.SetValue(parameters, ChangeType(Request.QueryString[key], propertyInfo.PropertyType), null); } } string guid = parameters.Path; int pageIndex = parameters.PageIndex; int pageNumber = pageIndex + 1; var displayName = parameters.Path; /* * //NOTE: This feature is supported starting from version 3.2.0 * CultureInfo cultureInfo = string.IsNullOrEmpty(parameters.Locale) * ? new CultureInfo("en-Us") * : new CultureInfo(parameters.Locale); * * ViewerImageHandler viewerImageHandler = new ViewerImageHandler(viewerConfig, cultureInfo); */ var imageOptions = new ImageOptions { //ConvertImageFileType = _convertImageFileType, ConvertImageFileType = ConvertImageFileType.JPG, JpegQuality = 100, Watermark = Utils.GetWatermark(parameters.WatermarkText, parameters.WatermarkColor, parameters.WatermarkPosition, parameters.WatermarkWidth), Transformations = parameters.Rotate ? Transformation.Rotate : Transformation.None }; if (parameters.Rotate && parameters.Width.HasValue) { DocumentInfoContainer documentInfoContainer = imageHandler.GetDocumentInfo(guid); int side = parameters.Width.Value; int pageAngle = documentInfoContainer.Pages[pageIndex].Angle; if (pageAngle == 90 || pageAngle == 270) { imageOptions.Height = side; } else { imageOptions.Width = side; } } /* * //NOTE: This feature is supported starting from version 3.2.0 * if (parameters.Quality.HasValue) * imageOptions.JpegQuality = parameters.Quality.Value; */ using (new InterProcessLock(guid)) { List <PageImage> pageImages = imageHandler.GetPages(guid, imageOptions); PageImage pageImage = pageImages.Single(_ => _.PageNumber == pageNumber); var fileStream = pageImage.Stream; // return File(pageImage.Stream, GetContentType(_convertImageFileType)); byte[] Bytes = new byte[fileStream.Length]; fileStream.Read(Bytes, 0, Bytes.Length); string contentDispositionString = "attachment; filename=\"" + displayName + "\""; contentDispositionString = new ContentDisposition { FileName = displayName, Inline = true }.ToString(); HttpContext.Current.Response.ContentType = "image/jpeg"; HttpContext.Current.Response.AddHeader("Content-Disposition", contentDispositionString); HttpContext.Current.Response.AddHeader("Content-Length", fileStream.Length.ToString()); try { HttpContext.Current.Response.OutputStream.Write(Bytes, 0, Bytes.Length); HttpContext.Current.Response.Flush(); HttpContext.Current.Response.End(); } catch (HttpException x) { // Ignore it. } } }
public HttpResponseMessage Get(int?width, string file, int page, string watermarkText, int?watermarkColor, WatermarkPosition?watermarkPosition, int?watermarkWidth, byte watermarkOpacity, int?rotate, int?zoom, int?height = null) { if (Utils.IsValidUrl(file)) { file = Utils.DownloadToStorage(file); } ViewerImageHandler handler = Utils.CreateViewerImageHandler(); if (rotate.HasValue) { if (rotate.Value > 0) { handler.ClearCache(file); } } ImageOptions options = new ImageOptions(); options.PageNumbersToRender = new List <int>(new int[] { page }); options.PageNumber = page; options.CountPagesToRender = 1; if (Path.GetExtension(file).ToLower().StartsWith(".xls")) { options.CellsOptions.OnePagePerSheet = false; options.CellsOptions.CountRowsPerPage = 150; } if (watermarkText != "") { options.Watermark = Utils.GetWatermark(watermarkText, watermarkColor, watermarkPosition, watermarkWidth, watermarkOpacity); } if (width.HasValue) { int w = Convert.ToInt32(width); if (zoom.HasValue) { w = w + zoom.Value; } options.Width = w; } if (height.HasValue) { if (zoom.HasValue) { options.Height = options.Height + zoom.Value; } } if (rotate.HasValue) { if (rotate.Value > 0) { if (width.HasValue) { int side = options.Width; DocumentInfoContainer documentInfoContainer = handler.GetDocumentInfo(file); int pageAngle = documentInfoContainer.Pages[page - 1].Angle; if (pageAngle == 90 || pageAngle == 270) { options.Height = side; } else { options.Width = side; } } options.Transformations = Transformation.Rotate; handler.RotatePage(file, new RotatePageOptions(page, rotate.Value)); } } else { options.Transformations = Transformation.None; handler.RotatePage(file, new RotatePageOptions(page, 0)); } List <PageImage> list = handler.GetPages(file, options); PageImage pageImage = list.Single(_ => _.PageNumber == page); Stream stream = pageImage.Stream; var result = new HttpResponseMessage(HttpStatusCode.OK); Image image = Image.FromStream(stream); MemoryStream memoryStream = new MemoryStream(); image.Save(memoryStream, ImageFormat.Jpeg); result.Content = new ByteArrayContent(memoryStream.ToArray()); result.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg"); return(result); }
public ActionResult GetDocumentPageImage(GetDocumentPageImageParameters parameters) { try { //parameters.IgnoreDocumentAbsence - not supported //parameters.InstanceIdToken - not supported string guid = parameters.Path; int pageIndex = parameters.PageIndex; int pageNumber = pageIndex + 1; /* * //NOTE: This feature is supported starting from version 3.2.0 * CultureInfo cultureInfo = string.IsNullOrEmpty(parameters.Locale) * ? new CultureInfo("en-Us") * : new CultureInfo(parameters.Locale); * * ViewerImageHandler viewerImageHandler = new ViewerImageHandler(viewerConfig, cultureInfo); */ var imageOptions = new ImageOptions { ConvertImageFileType = _convertImageFileType, Watermark = Utils.GetWatermark(parameters.WatermarkText, parameters.WatermarkColor, parameters.WatermarkPosition, parameters.WatermarkWidth, parameters.WatermarkOpacity), Transformations = parameters.Rotate ? Transformation.Rotate : Transformation.None, CountPagesToRender = 1, PageNumber = pageNumber, JpegQuality = parameters.Quality.GetValueOrDefault(), PageNumbersToRender = new List <int>(new int[] { pageNumber }) }; if (parameters.Rotate && parameters.Width.HasValue) { DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(guid); int side = parameters.Width.Value; int pageAngle = documentInfoContainer.Pages[pageIndex].Angle; if (pageAngle == 90 || pageAngle == 270) { imageOptions.Height = side; } else { imageOptions.Width = side; } } /* * //NOTE: This feature is supported starting from version 3.2.0 * if (parameters.Quality.HasValue) * imageOptions.JpegQuality = parameters.Quality.Value; */ using (new InterProcessLock(guid)) { List <PageImage> pageImages = _imageHandler.GetPages(guid, imageOptions); PageImage pageImage = pageImages.Single(_ => _.PageNumber == pageNumber); return(File(pageImage.Stream, GetContentType(_convertImageFileType))); } } catch (Exception e) { return(this.JsonOrJsonP(new FailedResponse { Reason = e.Message }, null)); } }
private static void ViewDocumentAsImage(ViewDocumentParameters request, ViewDocumentResponse result, string fileName) { var docInfo = _imageHandler.GetDocumentInfo(request.Path); var maxWidth = 0; var maxHeight = 0; foreach (var pageData in docInfo.Pages) { if (pageData.Height > maxHeight) { maxHeight = pageData.Height; maxWidth = pageData.Width; } } var fileData = new FileData { DateCreated = DateTime.Now, DateModified = docInfo.LastModificationDate, PageCount = docInfo.Pages.Count, Pages = docInfo.Pages, MaxWidth = maxWidth, MaxHeight = maxHeight }; DocumentInfoContainer documentInfoContainer = _imageHandler.GetDocumentInfo(request.Path); int[] pageNumbers = new int[documentInfoContainer.Pages.Count]; for (int i = 0; i < documentInfoContainer.Pages.Count; i++) { pageNumbers[i] = documentInfoContainer.Pages[i].Number; } string applicationHost = GetApplicationHost(); var documentUrls = ImageUrlHelper.GetImageUrls(applicationHost, pageNumbers, request); string[] attachmentUrls = new string[0]; foreach (AttachmentBase attachment in docInfo.Attachments) { List <PageImage> pages = _imageHandler.GetPages(attachment); var attachmentInfo = _imageHandler.GetDocumentInfo(_tempPath + "\\" + Path.GetFileNameWithoutExtension(docInfo.Guid) + Path.GetExtension(docInfo.Guid).Replace(".", "_") + "\\attachments\\" + attachment.Name); fileData.PageCount += pages.Count; fileData.Pages.AddRange(attachmentInfo.Pages); ViewDocumentParameters attachmentResponse = request; attachmentResponse.Path = attachmentInfo.Guid; int[] attachmentPageNumbers = new int[pages.Count]; for (int i = 0; i < pages.Count; i++) { attachmentPageNumbers[i] = pages[i].PageNumber; } Array.Resize <string>(ref attachmentUrls, (attachmentUrls.Length + pages.Count)); string[] attachmentImagesUrls = new string[pages.Count]; attachmentImagesUrls = ImageUrlHelper.GetImageUrls(applicationHost, attachmentPageNumbers, attachmentResponse); attachmentImagesUrls.CopyTo(attachmentUrls, (attachmentUrls.Length - pages.Count)); } SerializationOptions serializationOptions = new SerializationOptions { UsePdf = request.UsePdf, SupportListOfBookmarks = request.SupportListOfBookmarks, SupportListOfContentControls = request.SupportListOfContentControls }; var documentInfoJson = new DocumentInfoJsonSerializer(docInfo, serializationOptions).Serialize(); result.documentDescription = documentInfoJson; result.docType = docInfo.DocumentType; result.fileType = docInfo.FileType; if (docInfo.Attachments.Count > 0) { var imagesUrls = new string[attachmentUrls.Length + documentUrls.Length]; documentUrls.CopyTo(imagesUrls, 0); attachmentUrls.CopyTo(imagesUrls, documentUrls.Length); result.imageUrls = imagesUrls; } else { result.imageUrls = documentUrls; } }
public HttpResponseMessage Annotate(AnnotationPostedDataEntity annotateDocumentRequest) { AnnotatedDocumentEntity annotatedDocument = new AnnotatedDocumentEntity(); try { // get/set parameters string documentGuid = annotateDocumentRequest.guid; string password = annotateDocumentRequest.password; string documentType = annotateDocumentRequest.documentType; AnnotationDataEntity[] annotationsData = annotateDocumentRequest.annotationsData; // initiate AnnotatedDocument object // initiate list of annotations to add List <AnnotationInfo> annotations = new List <AnnotationInfo>(); // get document info - required to get document page height and calculate annotation top position string fileName = System.IO.Path.GetFileName(documentGuid); FileInfo fi = new FileInfo(documentGuid); DirectoryInfo parentDir = fi.Directory; string documentPath = ""; string parentDirName = parentDir.Name; if (parentDir.FullName == GlobalConfiguration.Annotation.FilesDirectory.Replace("/", "\\")) { documentPath = fileName; } else { documentPath = Path.Combine(parentDirName, fileName); } DocumentInfoContainer documentInfo = AnnotationImageHandler.GetDocumentInfo(documentPath, password); // check if document type is image if (SupportedImageFormats.Contains(Path.GetExtension(documentGuid))) { documentType = "image"; } // initiate annotator object string notSupportedMessage = ""; for (int i = 0; i < annotationsData.Length; i++) { // create annotator AnnotationDataEntity annotationData = annotationsData[i]; PageData pageData = documentInfo.Pages[annotationData.pageNumber - 1]; // add annotation, if current annotation type isn't supported by the current document type it will be ignored try { BaseAnnotator annotator = AnnotatorFactory.createAnnotator(annotationData, pageData); if (annotator.IsSupported(documentType)) { annotations.Add(annotator.GetAnnotationInfo(documentType)); } else { notSupportedMessage = annotator.Message; } } catch (System.Exception ex) { throw new System.Exception(ex.Message, ex); } } // Add annotation to the document DocumentType type = DocumentTypesConverter.GetDocumentType(documentType); // Save result stream to file. string path = GlobalConfiguration.Annotation.OutputDirectory + Path.DirectorySeparatorChar + fileName; if (File.Exists(path)) { RemoveAnnotations(path); } // check if annotations array contains at least one annotation to add if (annotations.Count != 0) { Stream cleanDoc = new FileStream(documentGuid, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite); Stream result = AnnotationImageHandler.ExportAnnotationsToDocument(cleanDoc, annotations, type); cleanDoc.Dispose(); cleanDoc.Close(); // Save result stream to file. using (FileStream fileStream = new FileStream(path, FileMode.Create)) { byte[] buffer = new byte[result.Length]; result.Seek(0, SeekOrigin.Begin); result.Read(buffer, 0, buffer.Length); fileStream.Write(buffer, 0, buffer.Length); fileStream.Close(); } } else { return(Request.CreateResponse(HttpStatusCode.OK, new Resources().GenerateException(new NotSupportedException(notSupportedMessage)))); } annotatedDocument = new AnnotatedDocumentEntity() { guid = path, }; } catch (System.Exception ex) { // set exception message return(Request.CreateResponse(HttpStatusCode.OK, new Resources().GenerateException(ex))); } return(Request.CreateResponse(HttpStatusCode.OK, annotatedDocument)); }