Technical FAQs

Accusoft’s PrizmDoc is a powerful toolkit for displaying, converting, annotating, and processing documents. This example will demonstrate how to use the PrizmDoc Cloud Server to upload a HTML document and convert it to PDF format, using the Java programming language.

The HTML To PDF Conversion Process

Converting a file with PrizmDoc Server takes 4 distinct phases:

• Upload: We start by uploading the file to the PrizmDoc server (it’s only stored temporarily while the conversion takes place). PrizmDoc will return a JSON file with the internal file ID and an affinity token, which we’ll need for the next step.
• Convert: Next, we ask PrizmDoc to convert the uploaded file by using the file ID returned from the previous step. In this demo, we’ll just be converting an HTML file to PDF – but PrizmDoc can also handle 50+ other file formats. PrizmDoc will now provide a ProcessID which we’ll need for the next step.
• Status: We need to wait until the conversion process is complete before trying to download the file. The API provides the current status of the conversion so we can download the file once it is ready.
• Download: Once it’s ready, we can now download the converted file.

Our Java program will reflect each of these steps through a class called PrizmDocConverter, that will interface with the PrizmDoc Cloud Server for each of the phases.

PreRequisites

For our code to work, we’ll need a few things:

• A PrizmDoc API key. This code example uses the PrizmDoc cloud server – sign up for a free evaluation API key here.
• Java Development Kit. This code was written for Java SE Development Kit 8, available through Oracle.
• JSON reader: PrizmDoc server uses JSON ( https://www.json.org/ ) to transfer data between the client and server. For the demo, we’ll be using the JSON Simple package. It can be downloaded and compiled through the Git project ( https://github.com/fangyidong/json-simple ), or if you’re using Maven download it as a Maven project ( https://mvnrepository.com/artifact/com.googlecode.json-simple/json-simple ).
• PrizmDoc server API credentials – sign up for free. The API key is provided after login:
  

Take the API key, and place it into a file titled “config.json” at the root of your project:

Replace “{{ valid key here }}” with your API key, so if your API key is “ur7482378fjdau8fr784fjklasdf84”, it will look like this:

Now we can code!

PrizmDocConverter Class

The PrizmDocConverter class uses 4 methods, corresponding to the 4 phases of PrizmDoc file conversion. The first part is to start up the PrizmDocConverter class.

Step 0: Loading the PrizmDocConverter Class

The first thing to do is to start up our PrizmDocConverter class. Using the Simple JSON package, we can get the apiKey field from our file:

We can now use our getAPIKey method to fire up the PrizmDocConverter class with the following call:

With the class started, we can start the next phase: Upload.

Step 1: File Upload

The PrizmDocConverter uses the method WorkFileUpload, that takes in the file name of the file we’re uploading and processes it using the Prizmdoc Work Files API:

The Work Files API takes in an uploaded file, and temporarily stores it for processing, so it is not available to other users through the Portal interface. The URL for the PrizmDoc Cloud Server for uploading Work Files is:

The Work File API uses the POST command to upload the file, and requires the following headers:

• Acs-api-key: Our API key. (If using OAuth instead, then follow the Work File API instructions instead: http://help.accusoft.com/SAAS/pcc-for-acs/work-files.html#get-data ).
• Content-Type: This should be set to application/octet-stream since we’re uploading bytes.

Start by setting up the URL and the HTTP headers. This example will use the HttpsURLConnection object to make the secure connections:

To upload the file, we have Java load the file into a FileInputStream, then read it through our HTTPSURLConnection:

When the file is uploaded, the Work Files API returns a JSON file with the details of the uploaded file:

To process this file after it’s uploaded, we need the fileId and the affinityToken for the next phase: Convert.

Step 2: Convert

With the file on the PrizmDoc server, we can now issue a convert request through the Content Conversion API with our ContentConvert method:

We use the affinityToken and fieldId we received in the previous Upload step. The format based on the versions supported by the Content Conversion API ( http://help.accusoft.com/PrizmDoc/v13.1/HTML/webframe.html#supported-file-formats.html ). In this case, we’ll use “pdf” as our conversion target.

This requires we upload a JSON file with the fileId and what we want to convert it to:

Note that it’s possible to request multiple files be converted, so if we were to upload a series of files, we could mass request conversions of all of them. With the fileId and affinityId extracted, we can start our request with the following URL for the Content Conversion API:

The following headers are required:

• Content-Type: The type of file, in this case “application/json”
• Accusoft-Affinity-Token: The Affinity Token we received from the Work File Upload
• Acs-api-key: The API key

To submit our request, we’ll construct our JSON file based on the fileId and affinityId like this:

Now we can upload our JSON string for the conversion request:

Getting the JSON file is the same as our WorkFileUpload method, and with it we’ll be able to download our converted file when it’s ready. Here’s the format of the JSON file our Content Conversion request provides:

The most important fields are the processId and the state, which we’ll take up in the next stage, Status.

Step 3: Status

Until the conversion request is complete, we can’t download the PDF file. To check the status, we use the same Content Conversion API call, with one difference: we use the processId as part of the URL:

This is very important – this is a GET command, but don’t try to use processId as a variable. Your URI will not look like this:

It must look like this:

For example, a processID of ahidasf7894 would give use a URI of:

With that, let’s look at our ConvertStatus method, which will query the PrizmDoc server via the Content Conversion API. This API will return another JSON file for us to parse:

This request is GET, with the following headers:

• Accusoft-Affinity-Token
• acs-api-key

Once again we get a JSON file back. There are three possible states:

• “processing” – The conversion is still in progress
• “complete” – the conversion is done, and we can download the converted file
• “error” – something has gone wrong with the conversion.

If the conversion is still processing, the “state” field will read “processing.” When complete, the “state” field reads “complete”. Our code puts in a loop that checks every 10 seconds, and when “state” is complete, we’ll get a JSON file that contains a new fileId – the one we want to download. In the event of an error, our program will print out the JSON file and exit:

Here’s an example of the JSON file we’re looking for when the status is complete:

We want to extract the fileId from the “output” node. Now we can get to the last phrase: downloading our file.

Step 4: Download

We’ll use the Work Files API again, only now we’ll use our new fileId to put in a GET request with the following URL:

Our Work Files API to download will work via the following method:

Our affinityToken we have from the initial WorkFileUpload process, and the fileId we just received from our ContentConvertStatus. The last is the name of the file to write out. In this case, it will be a PDF file, so make sure you have the file name set correctly. Downloading a file is nearly an inversion of our original WorkFileUpload request:

And with that – the conversion process is complete.

The Conversion Example

In our sample program, the conversion is called via a command line with two arguments: the file to be uploaded, and the name of the file to write the converted file to. In this case, our PrizmDocConverter class is wrapped up in a .jar called “PrizmDocConverter.jar” that contains our PrizmDocConverter class, and we make sure our execution is linked to our JSON Simple API to read the JSON files:

Replace the json-simple-1.1.1.jar with your version. With this call, simple.html will be converted to simple.html.pdf. Want to try it out for yourself? Get your free API key then download our sample project and test our the Accusoft PrizmDoc conversion system.

Goal

Create a Visual Basic (VB.NET) program that can generate a barcode in VB.NET from an existing table of data to represent shipping orders, then read single or multiple barcodes from image files to represent receiving orders.

Requirements

• Microsoft Windows 7 or greater
• Microsoft Visual Studio 2015 or greater
• Accusoft Barcode Xpress .NET

Programming Skill

Visual Basic Intermediate Level

Need to create a barcode generator and reader in VB.NET? Accusoft Barcode Xpress is a barcode generator and reader library that supports over 30 different types of barcodes, and can accurately read barcodes even when they are damaged or scanned at low resolution. In this tutorial we’ll create a simple order shipping and receiving example to demonstrate creating and reading barcodes in VB.NET.

VB.NET Barcode Generator/ Reader Sample Code

You can download the Visual Basic sample code here. Note that you’ll also need to install a free evaluation copy of Barcode Xpress .NET on your machine. 

[Download Code Sample]

Getting Your Project Set Up

For this example we’ll use Microsoft Visual Studio to generate our project files. After installing the Barcode Xpress .Net SDK, start a Visual Basic project. In order for this program to be properly generated, make sure that the Framework System.Drawing, and the Extension Accusoft Barcode Xpress 12 .Net are added to the project. The easiest way is to right-click on References in the Solution Explorer in Visual Studio, then click on Framework to select System.Drawing.

Then Click on Extensions and select Accusoft Barcode Xpress 12 .Net.

In the code for your Visual Basic project, place the following commands to import the libraries into your code:

And with that, let’s get coding!

Getting Started with Data

For this example, we will assume an environment where orders are being tracked in a database.  To represent this, we can use a simple table to represent orders that need to be tracked for shipping and verified that they were received. For our example, the following data is generated:

For this example, we’re going to work under the assumption that Order Numbers are unique values.

Generating Barcodes In VB.NETData

To track shipments, we can generate barcodes that that would be attached to the shipping label.  With Barcode Xpress, that’s a simple task. First, we’ll have our program look through the shipping table and any orders that haven’t been shipped (shipped is False), take the shippingOrder field and give it to our GenerateBarCodes function:

The GenerateBarCodes function leverages Barcode Xpress.  Barcode Xpress supports a plethora of barcode types – you can check them all out at http://help.accusoft.com/BarcodeXpress/v12.0/dotnet/webframe.html#Supported_Barcode_Types.html . For this example, we’ll use the Code 39 standard to generate our barcodes.

Here’s how we actually create our BarcodeExpress object and update the options:

What we’ve done here is create our BarcodeXpress object, set it to the Code39Barcode standard, and then set the barcode value to the current shippingOrder value.  All that’s left is to generate the barcode image itself and save it to a file. After that, the files can be used however we want – print them out as labels, embed them in documents – whatever works best.  We can leverage the Visual Basic object System.Drawing.Bitmap to do that for us.

That’s it!  A few lines of code, and when we call the GenerateBarCode function with a shippingOrder that equals A123456, here’s the result:

In the case of our sample program, it takes a few milliseconds to generate the barcode files and be ready for shipping.  Our function returns a boolean value if it’s successful, and our code then sets “shipped” to true and sets the date and time in our table of data.

Reading/Scanning Barcodes In VB.NET

So we’ve generated our barcodes to send out our shipments. But what about receiving them?  Using the same Barcode Xpress object, we can have the system scan in the barcodes, get the data from the barcode, look the order up in our table, then update the table to show the order was received and what time it occurred. Depending on how we receive the images will depend on your setup – but for this example we’ll just manually set a couple of files to test it out.

Here’s a simple example using one of the barcode files we generated:

Our program has a command line switch.  If you run it without any command line options, like this:

Then you’ll just have the barcode files generated off of our table.  Run it like this, though:

Where “imagefile” is a bitmap image with our barcode inside (such as, for example, the “C266760.png).  We’ll pick this up from our Main program like so:

Now we can scan our file with this command:

What we can do is generate an array of Accusoft.BarcodeXpressSdk.Result objects, then extract the values from there.  The function ReadBarCodes can be called via this method:

The function starts by taking the filename submitted to it, loading it into a Bitmap object, then using the same BarcodeXpress object. Only this time, instead of creating a barcode image, it can read from the bitmap image, and store the results into the Result object:

Scanning the barcode above will return an array with just one value in it – the barcode data for shipment C266760 from our example, and we can update our table of values to show this order was received and the date/time we scanned it:

But what if we have more than one barcode in our image, like this one:

Not only do we have multiple barcodes – but looks like someone slapped on one of them at an angle.  This is included in the sample as “received_002.jpg”.

Angled barcodes?  Not a problem. In fact, we can test this by displaying the table before and after scanning the file:

Success!

Even the one that was at a different angle was detected accurately.  Barcode Xpress can handle scanning barcodes in a variety of standards and formats, from multiple angles and even when the image has been degraded.

Ready to get started?

Check out the Accusoft Barcode Xpress free trial at https://www.accusoft.com/products/barcode-xpress-collection/barcode-xpress/ and give it a try.  Not into Visual Basic or .Net?  That’s fine – there are versions for Java, Linux and even your favorite mobile devices.

Corporate citizenship is often a box on a checklist that companies try to account for in their annual activities. But for Accusoft, corporate citizenship isn’t just a checkbox, it’s an integral part of the business.

From recycling bins lining the halls to the solar panels powering headquarters, Accusoft’s commitment to serving the community and reducing its global footprint is widely apparent.

Inspired by the passionate CEO, Jack Berlin, Accusoft’s commitment to volunteerism and giving back exceeds expectations when it comes to philanthropy.

A History of Corporate Citizenship

Jack has been passionate about the Tampa Bay area since moving from Georgia over 25 years ago. He is very involved with the local community and currently serves on the Hillsborough County Parks, Recreation, and Conservation Board and on the Environmental Lands Acquisition and Protection Program (ELAPP) site selection committee.

He encourages all his employees to do their part in the community by giving everyone the opportunity to champion a charity once a year with an Accusoft match. He also provides all employees with a day off to volunteer at a charity of choice without using any PTO. With all of these company-led initiatives, there was just one thing missing… the choices for participation.

A small group of Accusoft employees came up with the idea to create a group committed to brainstorming, organizing, and setting up charitable events for Accusoft employee participation.

A Dedication to Volunteerism

Accusoft’s Change Makers Committee was formed in 2018 as an initiative to provide a diverse array of options for employees to get involved. Inspired by Jack’s vision for corporate citizenship as part of everyday business, the committee has since organized and participated in 10 events.

In 2018 alone, the Change Makers volunteered at Feeding Tampa Bay, the Tampa Bay Humane Society, Habitat for Humanity, Coastal Cleanup, and more.

The projects were led by internal employees who organized and promoted the project with others. The Change Makers cleaned up Hillsborough River around Al Lang Park with Coastal Cleanup, helped build two homes with Habitat for Humanity, and donated numerous gifts including three bikes, an assortment of toys, and household items to the foster home known as A Kid’s Place.

The Change Makers Committee has not slowed down since. The Change Makers recently hosted a blood drive at Accusoft’s headquarters and have more opportunities in the making. Accusoft’s Change Makers Committee meets bi-monthly to brainstorm ideas and schedule volunteer activities in which employees can participate. It’s a great way to get involved and lend a helping hand.

Get Involved

Interested in working for an innovative tech company that cares as much as you do? Discover your future career on our job board.

The holiday season has always been a big event for the Accusoft team. It’s a great opportunity to bring the entire team together to celebrate the season and reflect on what we accomplished over the previous year. Since a few of our team members are located outside of Florida, we’ve even arranged to have them fly in for the holidays so they can participate.

Unfortunately, COVID 19 restrictions made it impossible for us to hold an in-person holiday party this year. Rather than simply shrugging our shoulders and cancelling the festivities, we tasked our “Event Ninjas” team with creating a virtual holiday event that could live up to those of previous years.

“Our holiday party is the most popular event we hold during the year,” said HR generalist Alissa Waters. “It was important for us to find a way to keep that tradition alive while still respecting the COVID guidelines we put in place as a company to protect our employees.”

Holiday Planning

The Accusoft Event Ninjas team consists of volunteers from every department within the company and meets once a week to plan various employee activities and events throughout the year. While the team is no stranger to planning a holiday party, this year posed significant challenges.

“The big challenge was figuring out how to incorporate that holiday feeling without meeting in person,” said Dawn Girard, marketing and events coordinator and Event Ninja member. “We didn’t want it to feel like just another virtual meeting.”

After some initial conversations, the team decided to incorporate as many longstanding holiday traditions as possible in order to give the event more familiarity. They couldn’t lean entirely upon precedent, however. This year would be the very first holiday party for a number of employees who joined the Accusoft family in 2020. The Event Ninjas team knew they would have to go the extra mile to make the virtual party as inclusive as possible and be an occasion nobody would want to miss.

Virtual Gift Package

Luckily, there was one tradition that could help get everyone in a festive mood. At previous parties, employees typically received a holiday card and a special ornament to commemorate the year. Since there would be no in-person event this year, they had to be mailed instead. That created an opportunity to get everyone in the holiday spirit by sending a special gift package that included a gift card and a packet of hot chocolate.

Why hot chocolate? The idea was that everyone could make themselves a piping hot cup to enjoy during the holiday party. “We wanted to provide a sense of being together even if we couldn’t be there in-person,” Alissa explained. 

All I Want for Christmas is…an Ugly Sweater(?)

If there’s one thing the Event Ninjas team learned after nearly a year of online meetings, it’s that any successful virtual event begins with a clear plan and a strong theme. The last thing they wanted to see was a bunch of faces staring blankly at their screen like they were waiting to discuss the latest marketing numbers (which, of course, is a very exciting conversation topic). They knew the party would need a compelling visual theme that would encourage everyone to tune in and get involved.

And what could possibly be more compelling than ugly holiday sweaters?

Everyone was encouraged to break out their most ghastly holiday apparel and prepare to cast their virtual votes for which sweater was a true “Nightmare Before Christmas.” The theme had everyone buzzing ahead of the event, which was just what the Event Ninjas team hoped for.

Party Time!

When the big day arrived, nearly the entire company logged into a “crowded” virtual meeting room to celebrate the occasion. Amazingly, the server didn’t immediately crash when confronted with so many ugly holiday sweaters all at one time! After taking in all the sweaters on display, everyone settled in with their hot chocolate to go over some of the highlights from one of the most unusual years in memory.

2020 Milestones

Life didn’t stop completely during the COVID 19 pandemic. Several Accusoft team members experienced personal milestones in 2020, including getting married, becoming a parent, buying a home, or getting a pet. The first portion of the holiday party was dedicated to these moments and to sharing work-related memories.

One of the most noteworthy events for the company was senior software engineer John Reynolds receiving a patent from the US Patent and Trademark Office. It was his third patent awarded during his time at Accusoft, a testament to our continued emphasis on innovation. We couldn’t be happier for John and are eager to see what he has in store next.

“We always want the holiday party to be a celebration of our employees,” Alissa said. “It’s a wonderful opportunity to recognize the people who make Accusoft successful.”

Service Awards

After the team shared their best memories and milestones for the year, Accusoft CEO Jack Berlin took the virtual mic to present a record number of distinguished service awards for the company. This year saw an unprecedented number of work anniversaries, with 22 people celebrating at least five years with Accusoft. 

• Five Year Anniversary Award: 10 recipients
• Ten Year Anniversary Award: 6 recipients
• FIfteen Year Anniversary Award: 3 recipients
• Twenty Year Anniversary Award: 3 recipients

When discussions about the virtual holiday party began, Alissa knew they had to make this section the centerpiece of the event: “It’s really important that we take the time to focus on these special employees. We want people to know that the company supports them and cares about them.”

And the Winner Is…

One popular portion of the holiday party that made a surprisingly smooth transition to a virtual context was the gift raffle. In years past, of course, the raffle was held in person and usually involved a long process of drawing names and having people walk up to the front of the room to receive their gift.

This year, the raffle turned out to be a fast and furious event thanks to the use of a virtual prize wheel that was preloaded with the names of raffle participants. Rather than dealing with multiple drawings, the Event Ninjas team could move from prize to prize with the click of a button and easily spin the wheel to randomly select a winner. It was fast, easy, and exciting. In fact, the team is even considering using the prize wheel for the next in-person holiday event!

Looking Ahead

After weeks/months of careful planning, our 2020 virtual holiday event went off without a hitch. While we’re looking forward to a return to in-person gatherings at some point in the next year, it’s good to know that our resourceful Event Ninjas team is more than up to the challenge of arranging a successful company-wide virtual event.

More importantly, we’re glad we could provide a platform for recognizing the success of our employees after this challenging year. Even though we were unable to gather in person, we were still able to celebrate everything that the Accusoft family has accomplished together. We’re looking forward to accomplishing even more in 2021.

As digital processes become more commonplace, it’s more important than ever for organizations to have the tools in place to manage electronic documents effectively. The evolution of PDF viewing technology continues to provide new levels of flexibility for software applications. Now that HTML5 is capable of rendering PDF data within a conventional browser, developers are looking for new ways to make the viewing experience even more seamless. By embedding PDFs in HTML, they can continue to streamline document viewing and reduce the need for external software.

Why Embed a PDF in HTML?

Sharing a PDF online is far easier to do today than it was just a decade ago. For many years, the two most commonly used options were providing a link to download the file directly from a server or sending it as an attachment in an email. Once the file was downloaded, it could be opened and viewed with PDF reader software installed on a computer. This, of course, introduced numerous security risks that are associated with downloadable files and email attachments.

The widespread adoption of cloud storage has made it very convenient to share a PDF file and even manage who has access to it. And since most modern browsers can view PDFs without needing to download the file, providing a link is typically all that’s necessary to pass the file along.

While this solution is usually sufficient for the personal needs of an individual user, it’s not a practical option for even a small-scale business when it comes to public-facing document management. Organizations want to retain control over their files with respect to how they’re accessed and displayed. By embedding PDFs in HTML, they can keep their documents within their secure application environment where they have full control over how they’re managed, shared, and viewed. For developers looking to provide a seamless user experience, building options for embedded PDFs into their software is critically important.

The Value of an Integrated PDF Viewer

Since most modern browsers can utilize HTML5 to render PDF files, developers could lean on those capabilities without building a dedicated PDF viewer for their application. That decision will very quickly lead to some unpleasant complications, however. In the first place, they are leaving a lot to chance in terms of the viewing experience. Not every browser renders PDF files the same way, so it’s very possible that two different users could have two very different experiences when viewing a document. In some cases, that could mean nothing more than a missing font that’s replaced with an alternative. But in other cases, it could mean that the document doesn’t open at all or is missing important graphical elements.

This approach also forces users to make do with whatever PDF functionality is incorporated into their browser’s viewer. In most cases, that will mean subpar search performance, a lack of responsive mobile controls, and no annotation features. The browser may also have trouble with some of the less common PDF specifications, making it impossible for some users to even view a document.

By embedding a JavaScript-based PDF viewer into their application, developers can ensure that documents will display the correct way every time. Since the viewing is handled through a viewer embedded into the web application by default, it will be the same no matter what kind of browser or operating system is being used. A customizable viewer also allows developers to adjust the interface to permit or hide certain features, such as downloading or markup tools.

The open-source PDF.js library is a popular choice for many web applications, but it comes with a number of well-documented shortcomings. In addition to lacking key features like annotation, it also doesn’t support the entire PDF standard and does not provide a responsive UI for mobile devices. For developers looking to add more robust features, working with PDF.js often entails quite a bit of additional coding and engineering to build those capabilities from the ground up.

Embed PDFs in HTML with Accusoft PDF Viewer

Accusoft PDF Viewer takes the foundation of PDF.js and provides robust enhancements to meet the viewing needs of today’s applications. In addition to incredibly fast text search, expanded PDF standard support, and optimization for high-resolution displays, this lightweight SDK is also equipped with a responsive UI that adapts automatically to mobile screens. Developers can integrate essential mobile features like pinch to zoom quickly and easy, with no additional integrations or engineering required.

With no external dependencies or complicated server configurations, Accusoft PDF Viewer integrates into a web-based application with less than 10 lines of code. Once the viewer is in place, developers can embed PDFs in HTML and easily render them to provide a state-of-the-art PDF viewing experience regardless of the browser or device users have at their disposal. And since the UI can be customized to your application’s needs, there’s no reason to sacrifice control for the sake of viewing convenience.

Accusoft PDF Viewer is a JavaScript SDK that you can incorporate into your application environment quickly and easily to provide much greater viewing control and functionality than is possible with a standard browser viewer or base PDF.js library. If you’re planning to embed PDFs in HTML as part of your software solution, taking just a few moments to integrate versatile and responsive viewing tools can ensure a high-quality viewing experience. Download Accusoft PDF Viewer Standard Version today at no cost to see how easily it can transform your application’s HTML5 viewing potential.

For additional features like annotation, eSignature, and UI customization, contact one of our solutions experts to upgrade to Professional Version.

Data privacy continues to be a significant concern for businesses, employees, customers, and stakeholders alike. Privacy breaches can expose problems with document management and digital document security practices. They can also pose significant risks and costs to companies and stakeholders.  The importance of ensuring the secure sharing of confidential documents can’t be stressed enough.

When developing an application with SDKs or APIs or integrating new features into a workflow, developers must be aware of the security risks. Project managers, security engineers, and architects must work in tandem to identify and address all potential security breaches. This holds especially true for commercially-confidential, highly-sensitive, or private documents while in transit.

The Risks of Document Sharing

Document sharing, in general, can present opportunities for malicious actors to attempt to gain access to a competitor’s documents. It could also pave the way for uploading data containing malware accidentally. Protecting the enterprise as a whole should be a priority to prevent loss or compromise of customer-sensitive information. This is vital because even minor damage to a company’s reputation can have a devastating impact. 

When building applications with document sharing capabilities, developers need to think about the inherent risks that come along with allowing users access to upload and edit documents. Fortunately, there are a number of practical steps that developers can take to share sensitive documents securely without putting confidential information or mission-critical data at risk. 

5 Ways to Ensure Confidential Documents Are Shared Securely

1. Strengthen Application Security

Any conversation about document security needs to start with a focus on the application’s cybersecurity architecture. If document management software contains multiple vulnerabilities or doesn’t provide the necessary controls to safeguard data, it will be difficult to share sensitive documents securely. Here are a few best practices developers should have in place to create a secure application ecosystem: 

• Perform threat-modeling any time there is a major design change in the application or ecosystem to identify potential new threats.
• Encrypt customer sensitive documents both in transit and in storage. Ideally, the keys will be held by clients with an emergency access vault backup system, so that even the software developer cannot access any sensitive customer data. This way, even if an application or data centers are breached, customer documents will still be protected.
• Spend more time testing releases for weaknesses and allow security engineers and architects to weigh in on the product feature roadmap. Security patches and improvements should be given the same value as other new product features.
• Conduct periodic audits or external penetration testing to ensure that applications and customer data cannot be compromised.

2. Design Applications with Segregated Access

Secure documents and sensitive information should only be available to the people authorized to view or edit it. Access to one document should not allow someone to access other documents stored in the same application. By segregating access to data and assigning specific user permissions, developers can provide the tools customers need to manage their assets and share sensitive documents securely.

3. Eliminate External Viewing Dependencies

Although many organizations use secure applications to manage their document workflows, they frequently open themselves up to risk by relying on external software for document viewing. Without some way of sharing and viewing documents within the application itself, files will inevitably be shared over email and opened on local devices that may not have the latest security updates in place. Developers can avoid this problem by integrating HTML5 viewing capabilities into their application. This ensures that documents never have to leave a secure environment, even when they’re being shared with people outside an organization.

4. Create Unique Viewing Sessions

One of the challenges with many cloud-based document management systems is that once someone is granted access to a file, they typically retain that access until it is manually changed at a later date. In most instances, those privileges are also associated with the source file itself. This can create a number of security gaps if an organization doesn’t closely monitor access privileges. By implementing an HTML5 viewer that can generate unique viewing sessions for individual users, developers can provide more control over how to share confidential documents. Viewing sessions can be set to expire after use, and since the session is viewing a rendered version of the document instead of the source document itself, system administrators have more control over what aspects of it are shared. They may decide, for instance, to share only certain pages rather than the entire document.

5. Implement Redaction Capabilities

Redaction has long been used to protect private or confidential information in documents. Although organizations still frequently make embarrassing mistakes when it comes to redaction, it remains one of the most effective tools for anyone who needs to share sensitive documents securely. By integrating true redaction capabilities that not only obscure, but also completely remove sensitive information, developers provide applications that have the ability to screen documents for privacy risks before they’re shared with anyone. Performing redactions within the application environment also has the benefit of further limiting external dependencies that could threaten security.

Protect Confidential Documents with Accusoft Integrations

Accusoft’s collection of processing integrations give developers with a variety of document management tools for controlling privacy within their applications. The HTML5 capabilities of PrizmDoc Viewer offer powerful redaction tools and make it easier for administrators to control viewing access. 

To learn more about how Accusoft SDKs and APIs can provide the document management features you need to protect confidential information and privacy, visit our products page today or talk to one of our integration specialists.

N-API.  Some time ago, way back in the Node JS 0.10.x days, we needed to expose some native libraries previously written in C++ for use by an existing Node JS based service. 

 There were two reasons to reuse this existing C++ code base:

1. The code was already written and debugged so wrapping it made a lot of sense from a cost perspective. 
2. The intellectual property was somewhat easier to protect in a binary than it was in a JavaScript module.

Fortunately, support for native modules was already available at the time, and we took advantage of them. Over the lifetime of that project, we ended up with a few breaking changes due to the instability of the Node.js Addon API through it’s early releases. Now, 5 years later, the planned backward compatibility support for the newer Node Native API sounds pretty exciting. 

Below is a brief history of the Native Node APIs and a look at the current new standards for native node development as of Node.js v10.

N-API

Like the original Node.js Addon, the new N-API is delivered as a part of the Node.js distribution. Starting with Node.js v8, it was delivered as an experimental feature and has become stable in the Node.js v10 release. The real benefit of N-API is that it is a true abstraction and is being developed to be forward compatible. For example, modules created with N-API v3 in Node.js v10 are guaranteed to be forward compatible with future versions of Node.js which should result in no rework as projects upgrade Node.js versions. The N-API / Node.js version matrix is shown below. 

C versus C++

Strictly speaking, N-API is implemented in C. While there is nothing preventing us from using the C implementation, there is a  C++ header only implementation that wraps the C implementation and is much easier to use. Additionally, if N-API adds new features and the C++ wrapper does not immediately wrap those features, but you still want to use them, there is nothing to prevent you from using the C implementation along with the C++ one in the same module. For the remainder of this article, we’ll be using the C++ wrapper.

So, what can I do with it?

Let’s look at a couple of simple examples and then move on to something more complex and useful. 

N-API can still use the node-gyp build system but additionally, it can now use CMake which is likely more familiar to C/C++ developers. If you are interested in using CMake, see the cmake-js documentation.

 First, let’s look at the N-API version of the hello, world example. The module itself is not a big departure from the other versions:

// hello.cc
 #include <napi.h>

Napi::String Method(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  return Napi::String::New(env, "hello, world");
}

Napi::Object Init(Napi::Env env, Napi::Object exports) {
  exports.Set(Napi::String::New(env, "hello"), Napi::Function::New(env, Method));
  return exports;
}
NODE_API_MODULE(hello, Init)

There is still a function definition (Method) which provides the implementation, and an Init function which defines the module exports. There is really nothing else of interest here.

The binding-gyp is slightly more complex than the original implementation: 

{
  "targets": [{
    "target_name": "hello",
    "sources": [ "hello.cc" ],
    "include_dirs": ["<!@(node -p \"require('node-addon-api').
include\")"],
    "cflags!": [ "-fno-exceptions" ],
    "cflags_cc!": [ "-fno-exceptions" ],
    "defines": [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ]
  }]
}

Like the previous versions, it requires the target name, source, and include_dirs, but it also adds compiler definitions to disable the C++ exception mechanism.

Node Addons, NAN, and N-API all support the features described below, but since this is a post about N-API, I’ll only be describing the N-API ones. 

Function Arguments 

Non-trivial functions require data on which to operate. In Node.js, as in other interoperability environments, data must be marshalled from the managed JavaScript environment to the native C++ module for use there. N-API provides helpers to do that. Consider a slight modification to our hello world example in which a name string is passed for the target of the hello.

// hello.cc - With a parameter
#include <sstream>
#include <napi.h>

Napi::Value Method(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();

  std::string arg0 = info[0].As().Utf8Value();

  std::stringstream str;
  str << "hello, " << arg0;

  return Napi::String::New(env, str.str());
}

Napi::Object Init(Napi::Env env, Napi::Object exports) {
  exports.Set(Napi::String::New(env, "hello"), Napi::Function::New(env, Method));
  return exports;
}

NODE_API_MODULE(addon, Init)

In this example, we get the first argument passed to the function and attempt to convert it to a Napi::String. Once that is available, we convert it to a UTF8 string and then use std::stringstream to format the output in order to return “hello, n-api” when the function is called with the string parameter “n-api”.

Callbacks

Most functions in node are not simple functions that just return a result, so in this section we’ll implement a callback that will return results through a function call.

// hello.cc - With callback
#include <napi.h>

void RunCallback(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();

  Napi::Function cb = info[0].As();
  cb.Call(env.Global(), {Napi::String::New(env, "hello world")});
}

Napi::Object Init(Napi::Env env, Napi::Object exports) {
  return Napi::Function::New(env, RunCallback);
}
NODE_API_MODULE(addon, Init)

The RunCallback function in this case retrieves the callback function pointer from the arguments passed to it by the caller in the same way that the string argument was retrieved in the last example. Before the function completes, it executes the callback function passing the “hello world” string as the first parameter.  The client code looks as you might expect:

const { hello } = require('bindings')('addon');

hello((msg) => {
  console.log(msg); // "hello world"
});

Unfortunately, this implementation does not provide actual asynchronous execution. In this case, the function call blocks until after it completes the callback. For true asynchronous execution, we require a somewhat more complex implementation.

Actual Asynchrony

Most functions in node are not simple functions that just return a result, so in this section we’ll implement a callback that will return results through a function call.

The AsyncWorker virtual class provides a nice wrapper to do asynchronous work and then hook the completion of that work in order to make a callback to the caller. In this example, we’ll take it one step further and return a Promise to the caller which will later be resolved or rejected depending on the outcome of the asynchronous work.

// hello.cc
#include <sstream>
#include <napi.h>

class AsyncWorker : public Napi::AsyncWorker {
public:
  static Napi::Value Create(const Napi::CallbackInfo& info) {
    Napi::Env env = info.Env();

    if (info.Length() != 1 || !info[0].IsString()) {
      Napi::TypeError::New(env, "Expected a single string argument")
          .ThrowAsJavaScriptException();
      return env.Null();
    }

    std::string input = info[0].As().Utf8Value();
    AsyncWorker* worker = new AsyncWorker(info.Env(), input);

    worker->Queue();
    return worker->deferredPromise.Promise();
  }

protected:
  void Execute() override {
    if(input.size() < 1) {
      SetError("EmptyName");
      return;
    }

    std::stringstream str;
    str << "hello, " << input;

    result = str.str();
  }

  virtual void OnOK() override {
      deferredPromise.Resolve(Napi::String::New(Env(), result));
  }

  virtual void OnError(const Napi::Error& e) override {
      deferredPromise.Reject(e.Value());
  }

private:
  AsyncWorker(napi_env env, std::string& name) :
    Napi::AsyncWorker(env),
    input(name),
    result(),
    deferredPromise(Napi::Promise::Deferred::New(env)) { }

  std::string input;
  std::string result;

  Napi::Promise::Deferred deferredPromise;
};

Napi::Object Init(Napi::Env env, Napi::Object exports) {
  return Napi::Function::New(env, AsyncWorker::Create);
}
NODE_API_MODULE(addon, Init)

To learn more, download my article to see how the AsyncWorker is used here.  Visit www.accusoft.comHome.

It’s never been a more pressing time to go digital. With over half of the world working remotely, we all need an easier way to complete our daily tasks. For some, this presents a unique challenge. Manual processes that require physical paper are now much more difficult in a work-from-home world. Expense report automation is one such challenge.

Finding a way to digitally automate those processes is now key. Especially when it comes to filing expense reports. Accusoft puts employees’ safety first, which is why we implemented new work-from-home protocols. While this comes with its own unique challenges, we are streamlining our processes by using our own technology to automate manual processes, like expense reports.

Digital Process Automation

Docubee is a business process automation tool, powered by Accusoft technology, that enables businesses to streamline a variety of different processes including document sharing, form creation, data collection, and digital signatures.

While Docubee is used for a variety of different processes, Accusoft is now using the tool to help employees during these unprecedented times. Accusoft was able to rethink the way we work, including the way we process expense reports.

Since most employees with a corporate card were always in the office, the process was more of a face-to-face interaction. Employees with a corporate card would print out their credit card statements at the end of each month, gather all receipts and invoices, print them out, write down a reference number for tracking, get their manager’s wet signature, and deliver the package to the accounting department.

“While this process has always worked for Accusoft, the Coronavirus forced us to take a deeper look at how we operate,” said Anthony Sanchez, Chief Financial Officer at Accusoft. “We have a great tool that can help us automate, and we are taking advantage of this opportunity to make the transition.”

A New Process for All

Using Docubee’s document sharing and workflow routing capabilities, employees were able to collect all of their receipts and invoices digitally, attach them to the new workflow, send them to their manager for a digital signature, and route the collection of paperwork to accounting for final approval. 

“Docubee is crucial in times like these,” says Steve Wilson, President of Docubee. “Our technology is powered by Accusoft’s powerful SDKs and APIs. As a business process automation tool, Docubee can help a variety of businesses take their processes digital.”

Accusoft discovered that using Docubee for filing expense reports is the perfect solution for the current circumstances and beyond. It streamlined the process for everyone involved, enabling employees to share statements more efficiently and managers to approve them with ease.

Do you have a manual process that has become more difficult during these work-from-home circumstances? Learn how you can take these processes digital and make your team more productive. Discover what you can do with Docubee.

Capital Investment Associates recently published their latest version of its Invest economic report. June’s edition focused on the economic outlook for Tampa. Invest: Tampa Bay is a 156-page economic analysis that reviews Tampa’s diverse economy, appeal for healthcare, tech and innovation, and much more. The 2019 report highlights the growth of Tampa’s businesses as well as the technological revolution the area is currently experiencing.

In the issue, Invest: Tampa Bay reviews tech and innovation’s impact throughout all economic sectors of the community. From residential and commercial development to tourism, arts, culture, and sports, Tampa’s growth reportedly “shows no end in sight.”

In addition to their own research, Capital Investment Associates reached out to the area’s top CEOs and leaders to get some insight on what it’s like to live and work in Tampa Bay. Accusoft’s Jack Berlin was asked to provide his thoughts.

The Technology Landscape in Tampa Bay

Tampa Bay technology has been top-of-mind for Berlin since he chose to locate his headquarters in Seminole Heights. To get the conversation started, Berlin and friend Seng Sun, owner of SunView Software, came up with the idea for Tampa Bay Tech, a group of CEOs that meet quarterly to raise awareness in and around Tampa’s software ecosystem.

“When Seng and I first met, we talked about the whole local software arena and we both lamented the same thing: nobody knows who we are, nobody knows what’s going on in software in Tampa Bay. We wondered if other people in Tampa Bay felt the same way we do,” says Berlin. “So, we put a group together and wrote down a few rules. One, you must be headquartered here. Two, you must be a member of Tampa Bay Tech. Three, you must have at least 10 W2 local software programmers – because we want real software companies in the area.”

Tampa Bay Tech intends to host some events over the next year, and engage others in the community. “I really do think that we have a bigger ecosystem than people know about here. This is a very small group of like-minded CEOs. We can have lunch together, nobody’s going to sell to anybody, we can talk about what we want to talk about. So, it’s very low key, it’s really just building a little bit of an ecosystem around software here,” says Berlin.

Passion that Makes a Difference

In addition to his passion for Tampa technology, Berlin insists that Accusoft employees get involved with the community and share a helping hand. Berlin serves as a chair of the parks board in Hillsborough County. “The experience exposed me to the wonderful world of our county park system. It’s expansive. As chair of the parks board, I became a member of the ELAP committee, which oversees land acquisition and the protection of these lands. A lot of it has to do with restoration and reclamation. We have over 60,000 acres under protection now as a county, which is incredible,” reports Berlin.

Berlin is still on the site selection committee, as well as on the board of the environmental land program. Additionally, he is a member of the Friends of the County Parks and Recreation Inc board, which is a different organization. This charity focuses its efforts around raising money for parks programs that aren’t funded through budget.

Accusoft enables its employees to take one paid day a year to go out and get their hands dirty. It even sponsors its own Champion a Charity program, where employees can pick a non-profit each year and Accusoft will match the donation. The company also has a Change Makers Committee that comes up with ideas for volunteerism and hosts different events throughout the year.

A Great Place to Grow

Accusoft is always growing and developing, but it keeps its charm with a small business approach. “Our core values and company culture make us stand out,” he said. “Accusoft fosters a competitive and positive work environment, and we are a place where people want to come to work every day. Even as we’ve grown into a large organization, we have a small business mindset where we value and support each individual employee.”

He provides this advice to entrepreneurs. “Go with your gut,” he said. “If you have a great idea, a go-getter attitude and a solid team, you will go a long way. I’ve had to make tough and risky decisions, but each one has excelled Accusoft as a company, and that comes from trusting my intuition and having a strong team behind me. Also, prioritization is key. As an entrepreneur, getting into the habit of deciding what needs to get done from day-to-day can be difficult, but ultimately, it will free up your time so you can focus on what’s incredibly important.”

To learn more about Accusoft’s interview with Invest: Tampa Bay, check out their economic report here.