Streamline Document Management with Automate

Richard: Okay, good morning, everyone. Welcome to our live webinar. Today is Thursday, July 23rd. I'm Richard Schoen, coming to you live from our offices in Eden Prairie, Minnesota today, where the temperatures should be a balmy 84, 85 degrees and sunny today. Barring any thunderstorms tonight, it should be the perfect day. I'll be the moderator for our webinar titled Streamlined RJS Document Management with AutoMate, brought to you by HelpSystems and RJS software. This webinar will provide an introduction to the AutoMate business process automation software and how the product can be used to streamline key document management processes when combined with your RJS Document Management software solutions. We're excited to have you here today, so let's get started.

As I mentioned, I'm Richard Schoen. I'm Director of Document Management Technologies at Help Systems. I'm part of the Technical Solutions Group at HelpSystems, bringing topics like this to our customers and prospective customers. I have over 25 years of background with IBM i, Windows, Linux and AIX platforms. My specialty areas are managing, automating and delivering documents electronically, helping our customers implement paperless process. My co-presenter today is Ricky Wilcock, one of our top technical solutions consultants for AutoMate. Ricky is located in our Los Angeles office in the heart of downtown L.A. Welcome, Ricky. Why don't you tell us a little bit about yourself and your role at AutoMate?

Ricky: Yeah, absolutely. So, good morning, everyone. Like Richard said, my name is Ricky. I'm a Technical Solutions Consultant with the AutoMate division of HelpSystems. So, what my basic job duties kind of entail is we work with our clients both in the pre-sale side and post-sale side of things. On the pre-sale side, we do a lot of product demonstration, consultation calls, build our client POV, you know proof of competence, things like that and then once our clients are kind of integrated in using our product, we work with them post-sale as well. So, doing trainings, implementations, migrations, all the normal professional service side of stuff.

Richard: Awesome and I know Ricky's answered several questions for me since I do a little bit of AutoMate demoing myself on coverage. Okay, a little overview on our agenda. Our agenda's relatively short today but we'll hopefully provide a good introduction to how your document management process from RJS can be extended via AutoMate. We'll provide a quick company overview of HelpSystems and its history, then Ricky will provide an introduction to the AutoMate software and the functionalities offered by the business process automation. Then, I will provide some examples of some web docs document management specific automation tasks that can be accomplished with AutoMate, along with some demo of the AutoMate task builder environment, so you can actually see the software in action.

So, we will end at the tail end with a few minutes of Q and A and, during the webinar, feel free to enter your questions in the chat window and we'll address them towards the end of the session. When you enter them, if you select all presenters, the questions get directed to me and Ricky and then we planned this complete webinar somewhere between 40 and 50 minutes, so you have plenty of time to make your next important meeting. The webinar's also been recorded, so you will receive a recording link so you can share this meeting with others in your organization.

All right, so a little background on HelpSystems. HelpSystems has been around for 32 years providing system management, business intelligence, and security solutions for IBM i, Windows, Linux and the AIX platforms. The RJS document management and AutoMate products joined the HelpSystems product portfolio in 2014, about three months apart. Our web docs family of products helps companies go paperless by providing several key document management components, such as document scanning to capture paper document, such as AP invoices and other paper documents, electronic business form output generation software, which can be used to generate documents such as invoices, purchase orders, statements, checks, other things. Our web form software is a web-based data capture component that allows companies to capture data at the source of entry and eliminate the re-keying of information, used often in AP, HR onboarding, and other departments looking to turn paper forms into actionable data.

We also have our sign here components, which are used for capturing signatures on business documents, such as invoices, receipts, [inaudible 00:03:55] deliveries and bills of lading without printing. And then finally, we have our deliver now product, which is used for automated report and date of delivery, document bursting, and those sorts of things. And then AutoMate, which really helps customers streamline and automate their key Windows based business processes, with over 600 different actions available. If you are planning to implement paperless process in your departments, chances are, we have the solution.

One more quick overview on our multiplatform offerings. HelpSystems offer several multi-platform products including automated job scheduling via our Skybot scheduling software, which can be coupled with AutoMate to form an end to end enterprise job scheduling solution. We have our network monitoring notification and visual network mapping software with InterMapper, which is a great product for that. We also talked about the RJS products already and then the business process automation, via AutoMate.

Today's webinar will be focused mainly on AutoMate and its business process automation functions but feel free to reach out to either Ricky or myself or the sales team after this call, if you have any questions or want to see a demonstration on any other software. We're always happy to show you what we have and how we can help make your life a little easier. And then, finally, here's a quick brief but impressive list of some of our customers using the AutoMate software. You can feel confident choosing AutoMate knowing many of the world's largest and well-known companies use our software to run their daily business processes. All right, enough commercial interruption. Now, we're going to turn things over to Ricky and provide a little overview on the AutoMate software for you.

Ricky: Perfect. So, let's briefly cover what is AutoMate. So, as you can see, AutoMate is an IT and business platform that allows you to create, manage and deploy tasks without running code. And we do this by using the pre-bill components called Action. These actions are used in a drag and drop fashion and configured by the user to create a managed task. These then managed task can then execute in response to some sort of an event. So, essentially, there's no need to learn programing language or be able to write a script when using AutoMate. This allows each individual user and/or department to create these automated tasks, without having to get outside assistance from developers. On top of that, we partnered that with built-in, centralized management of all of your tasks, error handling, reporting, different alerts and/or notifications as well.

Alright. So, this slide is our automation wheel and what this shows is many of the key areas where you can use automation. We won't jump into every single piece, but I want to highlight a few, especially the ones that can work really well with RJS. From a management side of things, AutoMate can do a lot of file management when it's moving files from locally network shared drives, for example, sending files via FTP and ASQ, files can be compressed, encrypted if they need to be. We also do a lot of application integration. So, if you want to do file management and transferring within your SharePoint site, we also integrate with that as well. Even cloud integration too, so we can work with Microsoft Azure, Amazon web services F3 for data storage. So, just kind of as you look through this, what you see is a whole lot we can do. The key thing to take away from the automation wheel is that AutoMate can stream together numerous amounts of independent process in a very cohesive manner.

So, this slide is our standard based approach to automation. This allows us to give our customers multiple avenues to the same destination. So, where many products only offer one way of doing something and force the client to confirm to their products, for example, we take the opposite approach. You'll see that we have a couple of different ways to actually integrate. You'll see that we can integrate using APIs and web services, run your existing command line CB power shell scripts or we can even integrate with your data on the back end. That means connections to your databases, for example, SQL, Oracle, IBMi and much more, even read from files and write to files, Excel, CSV, text, and even XML. We also offer front end GUI automation if we need to go that route as well. So, think about being able to integrate with any third application, web browsers, do legacy functions like terminal emulation. So, basically, in a nutshell, the standard base approach gives us the ability to map to your environment and not the other way around.

Triggers. Okay, so we talked a little bit about event based triggering, having these managed tasks kind of kick off automatically. So, what you're looking at here is the different triggers that AutoMate offers. So, these triggers, as you see, can be something as simple from a schedule to changes taking place in things like a folder structure or databases or SharePoint sites, even your event log, even system based events, like performance thresholds being met, the monitoring of Windows processes, services, can all be configured. These are all things that AutoMate can essentially monitor in a machine and anytime a condition or that event takes place, those managed tasks that you've configured using this drag and drop action will automatically run.

Richard: Awesome. I think your part is done. Excellent introduction to AutoMate software and I know I've been working with the AutoMate software since RJS became part of HelpSystems last year and just all those different Windows functionalities that you can tie into and we started doing some cross-pollinating into the IBM i jobs and things like that. It's just a great tool set and, for my background as a developer, I'm a dot net heavy guy. I'm a very heavy IBM i guy. What I like about AutoMate is being able to write all those business tasks and not having to write all the login logic or all the notification logic. You focus on the business logic and let all the run time stuff, all the triggers and all the logging take care of events. That's pretty cool stuff.

All right, so now we're going to take a look at some of the specific document management automation scenarios that can be accommodated using AutoMate with RJS. So, I've been working with the software a lot and putting together sample scenarios for our customers that might want to use it to augment some of what they're doing with document management. So, we'll take a look at a couple of those scenarios and we'll get a chance to look at the task builder as well. So, one of the scenario, this isn't necessarily web docs related but we run into a lot of customers, especially in the AutoMate demos that I do and that Ricky does as well, that have SharePoint and they want to publish documents out to document libraries, or they want to pull documents in, have people upload to a site and then be able to pull documents off the servers and then, obviously, in the case of AutoMate, also integrates to SharePoint lists and workflows and there's about 40 or 50 different other functionalities.

But, for our particular purpose today, we're going to look at an example of sending documents into a SharePoint library from a file system and how straightforward that is and it will give us a chance to get introduced to the task builder as well, which is probably where most people, when they're building their automation tasks, will spend their time. And just a side note, a lot of these are sample tasks that we've built that, if you do start implementing any of this with your RJS product, these are pre-built, I'll call them starter examples that you can get started with but we built in a lot of the functionality that you can use as just core process and then start adding your own logic around it. So, this particular process, so it's going to be a sample that reads and uploads documents to a SharePoint library. I think first I will give you just a little introduction to the task builder environment.

So, over here, we have the actions, which are all the things that you can do in AutoMate and I think I mentioned at the beginning we support about 600 plus different actions. Have we gone over 700 yet Ricky? Oh, we lost Ricky to mute, I think. So, in this case, you'll see if I want to add a new action to my task script, I can just drag it over into the development environment and what's nice about that is you can prompt for all the parameters that you need to fill out. And you'll see on the ftp action, it actually has several different things like log in, log out. So, I can start a session and then do several uploads or several downloads and then I can just pick and choose the different things that I need to do. And so I can either hard code information in here or we have an expression builder, too. So, you can use variables and information that's coming from a database or some other settings file. So, there's a lot of flexibility when you're building out your task scripts.

And for those of your customers that might be using IBM i, this might look like a graphical version of building CL programs on the IBM i, because everything is prompted, you fill it out and then it stores the task information, much like a CL program does. So, I always like to say that this is very similar to CL programing for Windows. So, we're not going to save this one, since we're actually working in our SharePoint sample. So, you'll see here I've got a couple of things where I've actually built out. I've got a variable in here for several things, like input directories that I'm monitoring, an output directory. And then, in this case, we're going to actually go ahead and we're going to connect to a SharePoint site. So, I'll show you how easy that is.

Typically, all you end up doing is you plug in your SharePoint site, you plug in a user and password, domain perhaps, if you are using a domain specific one, and then that creates a session that connects to the SharePoint server. One of the nice things, as well, is if you're using Office 365, which many customers are starting to move towards, we support that as well. So, you can have potentially your SharePoint environment in the cloud, or your customer portal in the cloud, and you can be sending documents to that and also receiving information from that portal as well. So, that's pretty nice. So, you've got out create SharePoint session. In this case, this is what we use to get a directory list, so this guy actually does a directory list. So, we want all the files from this directory and you can be very specific. There's all kinds of masking options, selectivity you can do.

My favorite one usually is I want to make sure that a file's at least 120 seconds old before I process it and you can have different thresholds but I like to say, usually, if a file transfer is complete and a file hasn't been changed in two minutes or so, chances are that any file transfers are done on that file. So, some people might have different, other tolerances but I always like to use two minutes as my favorite threshold. And then what this actually does is gets a list of documents and treats it like what we call a data set. So, every file name comes in and we're going to actually loop through each of those file names, we'll create a file that we're going to put out on our SharePoint site and then we actually upload the file with a single upload action into the SharePoint site.

So, here we just give it the input file name, the output directory and then the output file name that we want to generate and that uploads to our SharePoint. So, let's run this guy, and it's kind of fun because you can run these tasks interactively and, as you'll notice down at the bottom here, we also have all of the data and all the variables that show up during the processing as well. So, you can actually step through this and debug them, much like you would any other program, like visual basic.net or Csharp or CL or RPG, if you happen to be an IBMi programmer, but you can step through all those processes.

So, in this case, it looks like our process is completed normally, no errors. So, let's take a look at our SharePoint site here, drag it over. So, you can see in our sample SharePoint site, hopefully we should have a couple of new documents. Oh, I've got to click the demo document. That would help. There we go. We're going to just pick up our new documents that we posted. So, very easy to be able to post and also, on the reverse side, you can read information off your SharePoint site. So, that's a nice use of being able to implement SharePoint and use its collaboration features in conjunction with your RJS products as well.

So, in some cases, you might have a scenario where you want to use a document and collaborate on it out in the SharePoint site and then bring it back into web docs and check it out and check in changes to web docs as well. So, you can also do scenarios like that, where you use it in conjunction with web docs.

All right, a second scenario. We see this a lot in accounts payable departments. People want to be able to OCR their documents, either PDFs or TIFFs and actually extract information from those documents. So, the example there might be the digital mail room, where all documents get scanned in the mail room and scanned to a network folder and maybe needs to be identified based on the information in the document before it gets routed to a different department for processing, or maybe extract some information, if it's an AP invoice. We might want to pull off an invoice number or a total or a PO or something like that.

Once the images get processed, they get routed into web docs. So, basically you could setup approval processes or just store them there or maybe the data gets extracted into the AP system. There are a lot of different things that you can do. So, let's take a look at a little OCR task that we put together and show you how you could potentially do zone OCR. Now, as part of the RJS, we also do have, as part of our scan station, there's OCR built in and then we have a very high end product that will actually do line item, header data extraction as well. So, we use that but this is a kind of a nice middle ground for the mail room to be able to do some of the data extraction. So, we'll just run this guy and I think it'll go enough where it will allow me to talk at the same time, because it's using OCR, which is usually CPU intensive. So, it sets everything up. That just got a list of the files we're going to import from our directory. So, now it's extracting the top third of the image in this particular document and then it identified it as Industrial Plating as my customer and so now it's stepping through and extracting the invoice number. I think it's going to get the date here in a second, the amount, and this is running on my laptop, so it might not be as fast as it normally might be on a server.

Then, I'll display the text here when it's done, so you can see what it used for identification. So, just as an example here we display, this is the text that it pulled up the upper third of the document. So, we usually use that to identify or fingerprint what the document is before we actually pull the zone information off the document. So, it's a nice way to be able to extract data. So, we'll let it move on to the next document. So, when it's all done now, here it writes what we call an RDX file, which, in the RJS world, is an index file that gets checked in with the documents to set all the key information.

So, in this case, it's doing the second image, going through all the zones again, and then it should complete the process. It will stop here for a second and show us our information. So, there it is and then we'll let it go. And I think it's got one more that it needs to do. So, what's nice is this is a good building block for reusable tasks for custom maps that you might have as well, where you're going to be pulling documents into web docs and/or OCRing them or bringing them in via email, which we'll be looking at in just a moment, as well. So, those guys should be almost done. So, one more time, there is our upper third and that's how we identify it. We look for the customer information, and then determined it was Gamba and then we pulled off all the keys for that document. And there, it just completed.

So, let's take a look at the output information that we got out of that one. So, let's go back and pull this over here so you can see that. So, these are the documents that we outputted and, usually, I typically use unique file name or GUIDs, which are what these are called. So, you'll see I had a text file that got captured and in this case, well, actually, that's not the one I want. We want the OCR. Hold on a second. Here we go, that's better. So, in this case, we got our information. So, it pulled off the OCR. So, we pulled off a copy of the upper third of the document in case we want to use it in some of our import logic after we OCR. Because your process may not always flow the exact same way mine did, and then you'll notice, in this case, the documents are down here and then this is the index information that got extracted. So, on that one invoice, well, I'll show you in a second what [inaudible 00:19:17] looked like but I was able to pull off the invoice number, invoice date, the amount and the purchase order number.

Now, when that goes over to web docs, it'll just check in and those become the search keys automatically. So, it's a great way to be able to do inbound email or inbound invoice processing, in this case, by dropping images or PDF's into a folder and then OCRing them and capturing that data and then checking those into web docs.

Alright. So, our next example is sort of a modified approach to that, is we see often nowadays that customers, they're watching an AP inbound box or a different mailbox for information coming in and then they want to download those documents and then run them through the data extraction process and then index them into web docs as well. So there's kind of a variation on a theme but we're actually email. So, in this case, we'll show you our sample, this is our sample mail account here. So, we actually have an Outlook mailbox with my name in it. So, I've got two messages in there, one that has a single attachment, one that has two attachments. So, we'll take a look at that guy getting processed.

So, what's nice about the email functionality in AutoMate is it supports, for inbound, we support IMAP and POP3 and also Office 365 and Exchange directly, too, so if you want to open up in SMPP or POP, you don't have to do that and then the same thing for outbound. We support SMTP sending and then we also support sending via directly through Exchange, too. So, again, a department could potentially deploy this solution without having the IT team to give them access to the SMTP server because they can use their standard log in credentials, which is really nice.

So, let's take a look at our email capture sample. Sample three, I believe. And so, in this case, what we're doing, it's, again, a variation on our theme but what happens here is we actually go and create an exchange session and we log into Exchange. And so this is actually in the Outlook web access or, if it was Office 365, we'd be connecting directly to Office 365, and then what happens is, just like if you were listing documents in a directory, we're actually getting a list of all the Exchange objects or, in this case, it's the email object. So, what's nice is, much like we treat a directory list, AutoMate can treat an Exchange email message list as what we call a data set as well and then it can spin through those. So, just like other example, in this case, we're going to be emailing through the results from our mail search, and then I have a condition in here, I only want to process mails that have attachments. So, in this case, I actually spin through, process and extract the attachment data, and then we stop and you'll actually see what the header looks like and then we'll copy the information out so it can get indexed in web docs. So, we'll show that example as well. So, let's go ahead and run this.

Alright. So, you can see the first message it stopped at. One of the good things is that, you'll notice, we actually get the from, the to, the CC, blind carbon copy, the body, the subject, the date, and then the attachment. So, you can make all sorts of business decisions, including grabbing information out of the email or the subject line and using it for indexing, or maybe triggering off some other processing, too. We have a lot of customers that utilize email for a lot of different things. So, you could use email for a lot of things, even outside of web docs. And so, in this case, we'll let it continue. It's going to write all the indexing information for us out and then it's going to do another one, I think, and then we'll be done with this task. But these guys are very straightforward to put together. Once you have a building block approach, all I did is a built a sample process for looping through documents and then I was able to modify it to read through an OCR, I was able to modify it to use an email box and grab documents that way and continue forward.

So, in this case, you'll see here's the body text for our message. It'll continue through to completion. I think it should. There it goes, it just finished. And then we'll show you. So, in this case, what we did is we actually grabbed all the email information so you'll see we've got an attachment, which, in this case, is a PDF document. We have the RDX file which, for this case, if you were archiving emails, I simply grab the email address and the subject line because I just want to archive the body text with that information on it and my attachments, and then, also, you get a copy of the body text, so you can programmatically process that as well. So, I've talked to some customers that had some Windows processes whether they wanted to process and do something with the message body or, in some cases, move them all over to the AS400 or IBM i, then actually do processes over there with that information as well. So, being able to integrate all these different system types, we can integrate email very nicely into all your applications.

Alright, scenario, next. Okay, so in this case, we have business documents that actually, let's say you've got a user based business process or some sort of custom process your company is using to pull in documents. I see a lot of times where customers want to bring in engineering documents and they'll name them with underscores for all of the key information. So, in this case, you've got one that says key1_key2_key3 and then they want to monitor a network folder and web docs is smart enough, in most cases, to pull the documents apart and use the key names but AutoMate can be used to augment that process as well and be used as a building block to bring in those custom documents and assign all the key field information. So, that's a pretty nice feature.

So, let's take a look at our example for that. So, in this case, what we're doing, we're reading a directory content. So, again, just reading a file directory and I'll show you what it looks like. And then, what we're doing is we're going to actually parse the file names. Here we go. So, this example, I've got an invoice number, I've got a customer number and then a PO number on it, on these sample text file and then we use our delimiters to actually delimit the information in those files. So, let's run this task and this one should go pretty fast because, really, all it's doing is parsing the file names and then we're dropping out the index files as we go along through here.

Alright. I must have had a break point in there, so it stopped. There we go, same basic concept as our last one. There's a small loop where it spins through all the documents, it parses the file information apart. You'll see, right up there, it's parsing the file names, and then it's dropping out the file itself for capture to web docs and then it's processing the index files out there as well.

So, let's take a look at what it actually did on this one. There was our web docs input folder. Let's look at the output. So, you'll see what it did in this case, these are just text files that we grabbed, but then what it did is it grabbed all the key information. So, usually if I'm processing just the file name, I capture the entire document file name, the original file name as the title or maybe put it in one of the other keys, but then you'll notice it parsed all the other keys apart as well. And so, in this example, actually, I think the one we just did, there we go, is that one. You'll see this example, it's got the invoice number, it's got the customer number, and the PO number.

So, one of the things that customers like to do, typically, is, in this case, I have that information. It's not in web docs yet, but a lot of times, we get asked to go grab additional information. So, the next sample, we're actually going to go and modify this to go integrate to the database to get some customer information. So, we'll come back to that one in just a moment and we'll do another sample here.

So, to extend what we just did here, as I talked about, we can easily integrate lineup business data into the document capture process. So, think of new document scans are coming to our web docs scan work station or they come in via email, and let's say we're able to pull key information off the document but we want to get the rest of the index data before it goes into web docs. In our next sample, we'll actually look at a small modification to the last sample that we did that allows us to go into the customer database and get information. So, it could be any table, J.D. Edwards, SAP, any SQL server or Oracle or any database system that you have or, if you've got Access database or text files, CSV, XML, pretty much any data that we can actually go read information in from, so that's pretty nice. And so the idea is you want to add that additional key information in the backfill.

So, let's take a look at our task for that one. So, basically take this last example that we just did and we'll go over one more and do that. So, the only key difference here is, so this guy is actually establishing a database connection. In our case, it's talking to an IMB i. It's connecting up with the data source and it's doing the rest of the process that we did before. We'll get a directory list, we'll spin through all the documents here, and then you'll notice, when it gets the key four, it's actually going to do an SQL query. So, if you look in my example here, we'll pop it up. You'll see I've got an SQL select, I've got it soft coded at the top and then, what I do is, I grab the value of key two, which was our customer number, and so it's going to query that table for the record that matches that customer number. So, we can fill in the last name.

So, in this case, you'll see it basically does the query and then it loops through and it says I only want row one during these loops, so I can get the first record that came back for us. And then what it does is sets key four equal to the, so the data set, when we do the query, it always come back in a data set, which is a programmatic structure to see the fields of the record and then we put the field name there. So, we're actually filling in key four with the last name and that was the only change to our sample that we just did on our last example. So, this particular one would parse the file names and then, based on data that we want to go into the database with, it'll actually pull in and fill in the last name. So, let's go ahead and run this and then we'll take a look at how it changed the output.

Had the same breakpoint as my last one.

So, those of you familiar with web docs will be familiar with that. We have  I think on the web docs, we have ten keys and web docs Windows we have 30 distinct keys. So, you can see that's coded in these particular scripts so you can take advantage of all the different key fields for any particular document type. That's pretty handy.

So, let's take a look at this guy. That probably would have been our most recent one we just captured. So, you'll see, in this case, what it did is it's got the file name, it's got invoice number, customer number, PO number, and then we got the last name because we went to the IBM i database to pull that out of our customer file. So, you could with any number of these, where you're back filling information. A lot of times, especially with payables, if we have a purchase order number we can go right into the purchase order, we can match amounts up against receiving files or against the purchase order, too. So, we can actually use AutoMate to do some of the two and three way matching that you might need to do in a purchase order process as well. So, a lot of different things that you can do with some of the integration components within AutoMate, to augment what you do in web docs. So, pretty nice stuff.

Alright, so, we're going to take a little time for some question and answer. When entering your questions, again, please remember to select all presenters and direct your questions for me or Ricky and then we'll give you about a minute and then we'll address any questions.

Okay, so here is one that I received. So, what other things can I do with AutoMate to automate my daily tasks? Well, I think Ricky touched on a lot of the functionalities that you can do with AutoMate in terms of just general day to day automation but a lot of times, I think on probably 90% of my calls, and I think Ricky mentioned this as well, is I see FTP file transfers. People want to manage file transfers between a trading partner site and either the IBM i or into one of their other systems. So, we do support FTP, FTPS and SFTP for file transfers from and to trading partners as well, as well as the data encryption that we talked about.

Also, on the side of the interactivity, a good use case for that is I see a lot of customers, where they have to go in and download information from a bank or they have to go to a trading partner site and grab information and things like as well. So, a lot of times the web browser interactivity is really nice because you can actually automate, in some cases, we've helped cost justify it for customers based on they have one employee that does this all day long. So, what we're able to do, in some cases, is actually automate the process where you might get a notification that there's a bank document or a trading partner document out at one of your partner sites and then you can actually grab that email, go cause the interactivity to log into the website, navigate through the page it needs to go to, and then download a document or maybe it needs to enter some data or something like that.

I always look at managing each website interaction or if you're automating a Windows app or a Java app, I think of those as mini work flows. Typically, the idea is that you have to articulate how does this normally flow and then, typically, we can script to automate with interactivity to handle that. So, that's for those edge case tasks that you can only do through interacting with the application. There's a lot of old code out there as well and old ERP systems that the only way to automate stuff is through menu actions and things like that and you can't get directly into the data base. So, you being able to automate a user interface is huge, in terms of being able to automate some of these older applications. Also, extracting data from a database, to Excel or reading Excel files and entering data into a database, can really be streamlined for data entry because a lot of times, people do file uploads or they're hand keying data, so just being able to automate that process is pretty cool.

In fact, actually, I have a quick sample I'll show you while we're here that I still had open. Here is, we have one for doing, this is a sample one that I always use to illustrate how quickly you can actually do a data extraction with AutoMate. So, this is cool because you actually see we've got a SQL statement, so it selects some data and then it's outputting to an Excel file. So, we've got a variable for the Excel file name and then we actually have an action called create new spreadsheet and one of the nice things about AutoMate is we can actually create and modify spreadsheets, either directly through Excel by automating Excel, which means we can call macros, but we also have, as version 10, we also have the open document API, so you can read and write Excel without actually having to have Excel. So, in this case, we're creating a new spreadsheet file, we're always overwriting at each time, because that's the way I wanted it to happen, and then what I do is I always write to the Windows Event Log. So, it's always nice to log what's going on and there's a lot of different ways to log stuff through AutoMate, but I tend to like the Windows Event Log.

And then what this actually does is drives the connection to our database. So, I think Ricky mentioned earlier, as far as databases we can connect to, anything with a database driver that runs on Windows, pretty much, we can connect to. So, I think most databases have ODBC, even the older Microsoft Access and Box Pro and some of those things have database connections you can use. So, this actually connects up and creates a connection to our database and then you'll see, there's one line of code that we put in here to actually run the SQL query and it brings all the records back into a memory space called a data set. So, what's nice is that this can be used over and over again. And then there's a one liner that you actually use to write to an Excel file, so look at that. So we have a data set. Starting at row and column one, I want to write all this data and I want to write it with the column names on the first row and then it closes everything up. So, it closes all the connection and then, for my sample, I actually open the Excel file as well. So, let's run that while we're thinking it through here.

But what's nice is AutoMate tasks can actually be both in the building blocks, and you can take this guy as a starting example, and turn it into a standard data extraction module with ten lines of script in it. You just pass in an SQL query, maybe a database connection string, and an Excel output file and maybe an email address or a directory, if you're putting into the SharePoint or web docs and you've a got a reusable module from all of your applications that can do very quick data extractions into Excel. It's a pretty powerful stuff. That was a long answer to a short question there.

Also, can I create AutoMate with any of our other HelpSystems products that I might own? If you own other HelpSystems products, AutoMate is starting to find its way into integrating with many of our other products. We've already tied it directly into our Skybot scheduler and I always like to think of AutoMate as the glue that fills gaps between some of our other applications. One of my colleagues always likes to say is everybody needs AutoMate because, we've run into a lot of customers. There's nobody that doesn't have a Windows server in their environment today, or doesn't have automation tasks that they need to accomplish. So, being able to use AutoMate for that is really nice.

And I've done some proof of concept work on integrating Active Directory with our Power Admin software from Power Check as well, where we can create users over an active directory and then create them over on IBM i. So, there are all kinds of user on-boarding things you can do with AutoMate, Power Admin and with other business systems that you have. I know one of the heavy uses of AutoMate itself is for user on-boarding and processing users and active directory. So, a lot of good things. And, if you have any ideas for other integration items you'd like to see, make sure you reach out to me or Ricky in the sales team as we talked about at the beginning. There are all kinds of uses.

And then one other question I think we have here is, can I connect into the IBM i when running tasks? If you're using the IBM i client access driver, you can connect directly into the IBM i to read and write data, you can also call existing programs, if you set them up as stored procedures, which is pretty easy to do. So, you can integrate and grab program responses directly right back into your AutoMate tasks. So, really, an AutoMate task can be a full participant in the IBMi job stream, in some cases, where you might run something over on the Windows server, you need to go call something on the i and get a response and then continue on or maybe extract some data. So, like we talked about, on a data base front, AutoMate can pretty much connect into any database and run programs or store procedure and all of that sort of stuff. Alright, let me see. Ricky, are you seeing any other questions? I don't see.

Ricky: I don't see any of the questions at all.

Richard: Okay. Yeah, so, if you do have any other questions, I'm not seeing anything else in the chat window here, so we appreciate you joining us today. Thanks for allowing us to show you AutoMate technology and how it might work with RJS and you might have spurred some other ideas on your general business processes that you can use to AutoMate with as well. We hope you found the webinar useful and we look forward to helping you demo, test or implement our software to automate your web docs and other Windows based processes and document processes. If you have any questions about today's presentation, AutoMate or web doc's functionality, please feel to reach out to our sales team, me or Ricky, or anybody at HelpSystems here and we'll get you to the right person. So, we appreciate you joining us this morning. Have a great day and enjoy the rest of your week.

Ricky: Thank you, everyone.