SpringCM REST API | Developer Deep Dive

[MUSIC PLAYING] Hi, my name is Matthew Roknich. I am the Developer
Evangelist here at DocuSign. I’m here today in Chicago with
Keith Litwin, who is a Senior Director of Engineering. Keith, thank you so
much for being here. Thanks for having me, Matt. So Keith, how did you get your
start in software engineering? Well, I’ve been in technology
for a little over 20 years. I started out during the
.com boom selling computer equipment. Really loved it. Went back to school to
learn software engineering. Since then I’ve worked in big
companies, like Oracle and IBM, as well as smaller startups. And then I came to SpringCM. Been here for a little
over nine years. I started out as our Lead
Solution Engineer building custom solutions. Worked my way up to
VP of Engineering, which was my role at
the time that DocuSign acquired SpringCM. Very cool. So what are you
currently working on? What’s your focus? Kind of two main focuses. So we’re building
out some new products that are leveraging the SpringCM
platform, as well as we’re continuing to build out our
contract lifecycle management solution, which is
part of DocuSign’s overall system of agreement. So contract lifecycle
management– what exactly is that? Well, that generally
refers to a secure platform that allows you to generate
documents, route them for approvals, and manage
negotiation and redlining. Really it helps you automate
any document-centric business process. Now, within the context of
DocuSign system of agreement, SpringCM fits perfectly into
what we call the prepare stage. Where we’re enabling customers
to create and collaborate with one another prior to
sending out the agreement. So it sounds like
SpringCM brings a tremendous amount of
value to our customers, but what about developers? I was very excited to hear
that SpringCM has a REST API. What specific functionality
is accessible to our devs? So the API allows developers to
work with SpringCM’s documents, data, and services. And pretty much almost
anything that you can do inside SpringCM user
interface is exposing the API. The way to think about it is
that the API is broken down to kind of 3 logical sub-APIs. There’s the object API, which
is your standard create, read, update, delete operations. Examples there might be I
need to create a folder, delete a folder, create
a user, create a group, put user in a group–
those kinds of things. There’s the Task
API, which you can think of as being like
asynchronous background tests, or I want to give
SpringCM a piece of work to do on my behalf. And examples there might
be generate a document, run a search for me, zip a
bunch of files for download, and that kind of thing. And then there’s
the Content API, which is working with the
documents themselves, which would be like upload, download,
and versioning of the document. Excellent. I suspect a good
number of our viewers are relatively
unfamiliar with CRM. Do you have a demo
you could show us? I do. And what I’m going
to talk about today is one of our most
common use cases, which is contract lifecycle
management within Salesforce. And so to set the
stage for that, we’re going to use
an example scenario where we have a
sales rep, Ernesto, who needs to close a deal. And he needs to
generate a sales order, and part of sending
that out will have to go through an approval
from his manager, who’s Keith– I’ll play that role– and then Kathy, who is our
customer that will ultimately have to sign it with DocuSign
electronic signature. So what we’re going to show
is dynamically generation of a document based
on Salesforce data, we’ll show how the routing
and approvals work, and then we’ll ultimately
see our sales order go out for electronic signature. OK. So here we are inside
Salesforce on an opportunity that we’re going to
use for our demo. In this case, like
we talked about, here’s our opportunity,
Ernesto, and he’s our sales rep that’s going
to generate a sales order. We’re here in the
contract legal space ready to send this
out for review. So I’m going to go ahead and
click generate sales order. And that’s going to
take us into a new tab into the SpringCM document
generation wizard. And what you can see
here is that it actually dynamically pulled data
from Salesforce in here, and you can see the adjust
information is pre-populated, the primary quote information
is pre-populated, as well as the quote lines. And then we can do some
interesting things in here. Like if we wanted to attach
some additional documents with our sales order or
we can come down here, and let’s say we want to switch
our payment terms from net 30 to net 45. Now when I switched that,
notice what happens here. We have a rule that
was set up that said modification of payment terms
require management approval. So this is great for
our demo for our phase 2 when we want to send this
to a manager for approval. And then I’m going to
go ahead and click Next. And so this is building
our document preview. It’s taking that structured
data that we just pulled here into the wizard. It’s taking a Word
template document that we pre-created
and now it’s showing us a preview of what our document
is going to look like. We can see our order form. Here, has the data
pulled in from Salesforce nicely formatted that it’s
ready to go out to our customer. Now, I’m going to pause over
here and pull up some code. So let’s say, for example,
we’re not using Salesforce. We have some other
third party system. It might even be
some homegrown system that you have and you want
to do document generation leverage a wizard
like we see here, you can do things like as
simple as creating a template and choosing which
one you’d like to use. Creating some structured data. In this case, we might have
queried a database or something along those lines. And then doing a
simple post to the API. Say here’s the data,
here’s the template I want, and it gives me back a URL to
go ahead and launch the wizard. And there’s even the
sub-services underneath that. Let’s say I just wanted
to generate the document– I could give it the
structure, data and template, and just say, we
don’t need the wizard, just generate the
document, and off it goes. So next I’m going
to come in here and I’m going to go ahead
and save the document. And that’s going to take us back
into our Salesforce opportunity and what we’re going to see,
when I scroll down here, that our document
has now come in and is associated
with our opportunity, inside a SpringCM folder
that’s associated with it. And I’m going to take a look
at the generated document. And there’s lots of
interesting things that we see. So the first thing that we
see is the current stage. So the document was
generated, and now it’s gone straight into Manager
Approval, because we saw that earlier, that that’s
what was required for net 45. I’ve come over here,
now, to Attributes– so the document was tagged
with the data from Salesforce, so inside SpringCM we
could use this data to do queries and searches,
reporting, that kind of thing. And then there’s
all kinds of actions we can take on the document. So we could upload
a new version, and we can send for
external review, we could share it with
somebody, we can maybe look at the history, and
other pieces around what we’ve done here. But for our demo,
let’s assume that we want to build, let’s say,
a mobile application that’s leveraging this document,
and do something interesting with
the API, or maybe surface this in a portal or
some third party application. So let’s take a look at what the
document looks like in the API. So what I’m going
to do is, I’m going to grab this document’s
unique identifier right here off the query string. And I’ve set up a
test harness where we can query the
API in real time and see what this
document looks like. So I’m going to go ahead in
here and populate this field with our document
ID, and I’m going to go ahead and query for it. And what we can see back– as
we get back our document object, our API representation
of our document object– are sales order, description
was agreement and review, like we saw. And then we can start to
see these child objects that are associated with it. For example, here’s our parent
folder that the document is in, you can see it’s not expanded,
but it gives us an endpoint. If we’re interested
in the parent folder, we can do a query on it. So I have that set up
already for us over here, and I’m going to go
ahead in and query. Now what’s interesting
is, I look at the– with some standard
things like a name, created data, update to date– I’ve also see our child
set of documents here. So like we saw, our
new generated document. And then, what’s interesting
is this object called EOS Info. And notice that it has the
object ID from Salesforce, and the object type of
Salesforce opportunity. And what’s interesting when
I asked for the document, up here on the query
string– excuse me, asked for the folder– I have Salesforce
opportunity and EOS Object ID, which is the
Salesforce Object ID, and then set expand
equal documents. So here, right in
the query string, I’m actually querying
by the third party system, Salesforce’s object ID. So when the folder was
created, we tagged it, and that way, if–
let’s say you’re building your own application
that needs storage, you can use data from
the third party system and not have to manage
like, SpringCM, Object IDs, and things like that yourself. So let’s go back to
our document object and look at that a
little bit further. And as we scroll down, we
can see some of the objects, like attribute
groups, are expanded, and that’s because on the
query string here I said, you know what? When you give me
this document, I don’t want to make callbacks
like I just did for the folder, just give me all the attribute
groups in this other object document process
tracking activities right on the first call. And so here you can see,
just like we saw in the UI, we can see things like
our quote number, who prepared the document, the
quote expiration and things like that, and that could be
used in our custom mobile app to show the end user. And as I scroll down, you
can see all the other kinds of things, like security
around the document, how to version
it, whether or not I want to share the
document, that kind of thing. And then we get to our document
process tracking activity. And this is an interesting
object in that it’s actually showing us the approval. So for our end user, we can
say it’s assigned to Keith, it’s in status for its
status waiting, waiting for the manager to approve it,
and then what potential user actions are. Now in a normal CLM use
case, we wouldn’t necessarily come into the document first. We would– because the
manager’s not navigating to the opportunity and looking
for things for him to do– we just want that to
sign directly to him. So in a normal
use case, he would have something like this, like
the SpringCM Inbox Tracker. And inside here, when I
refresh, it says OK, well it’s mainly for management approval,
so these are the tasks that are assigned to me. And if I were to
click review here, it takes a slightly different
view of the document. It takes us straight
into the approval flow. And now, remember
our three phases, where we said first we’re going
to generate the document– so we’ve gone through that,
we saw what the document looks like– now we’re in the
second phase, where we have to do a manager approval. OK, so let’s dig a
little bit deeper and to see what that looks like,
in both the UI and the API, if we’re building
our mobile app. So inside here, you can see that
this particular approval just is a simple one, it just
says approve or reject, and allows you to do
some simple comments. In this case the workflow
is set up to say approve, it will go out for Docusign
electronic signature. In the case where
we rejected, it might be sent back to
Ernesto, our sales rep, to go ahead and
make some changes. We can give him some comments
and things like that. OK so let’s come back over
here to our test harness and see what we can do here. So I have another query set
up, and this is basically the equivalent of what
we just saw in the inbox. So give me all the
tasks that are assigned to Keith, and in the
API, that’s actually considered a work item
or a piece of work that an end user has to do. So here you can see I have
queried for user/ –and this long GUI is actually my user
ID, so I had that pre-set up, and then /workitem to say,
give me the actual inbox or the collection of work items
that are assigned to Keith. And so here we can
split our users, and here’s all of
the tasks that you have to do, and allow them
to potentially take action. So if we want them
to take action– I’m going to go ahead now and
grab the unique identifier for our current work
item right here, and I’m going to set
that in our variable so that we can make
some queries against it. So I’m going to go ahead
and do that right here. And let’s make sure that we have
the right object, and go ahead and query directly
for that work item. Now when I query directly
for the work item, notice I get a little
bit extra information. I get this selections
right here, and it gives me the options of
what the end user can actually do, they can either
approve or reject. In the case where we do
something more complex, you’ll have other
options there, we might prompt the user
to choose another user to do the additional approvals,
or maybe extra documents, and things like that. But our case, we’re going
to do a simple approval. And let’s say we want to
approve this with comment, I have a patch set up here. And our payload
will look like this. So now we’ve chosen selected,
the item was approved, right? Some of approvals might have
multiple options, in our case, it’s simple approval. And then our comment,
this is a great demo, we’re going to post that back
to the work item end point, clicks send. So we got back 200, and let’s
go back to our Salesforce UI, and reopen up the document
and see what happened. So now we immediately see that
the status of the document is changed. So we see the
manager approval, you have approved, it’s gone
out for electronic signature to Kayla174, which is our test
user, which would normally be Cathy Customer, which is
CH3, that we talked about. So now we’ve done the
document generation, we’ve done our approval,
and now the final phase is out for signature. So let’s look a little
bit closer at that. If I come back over
here to our document and just query for
it again, we can see now our document
process tracking activity says send for signature. And it can tell that
it’s in a waiting status, that string states I’m
waiting for it to be signed, for it to come back in. We can see that it was
signed to [email protected], and if we come back over
here to actually the inbox, we can see that the signature
request was sent out by Ernesto, and said to go
ahead and review the data. OK, so– our first phase,
second phase, and third phase will now be complete
once it signed. Now I’ve been talking
a lot about workflow. And that’s an important
piece of the story here, in terms of– we have
the UI and the API that’s interacting with these work
items, and what we’ve done is pre-created a workflow
here that kind of models the business process. And we’ve been mostly talking
about the prepare phase– created the document, now
kicked off this workflow. We can see that some decisions
were made about the document. Comes through to
approver one, where we saw that we programmatically
execute on that in the API. And once that was completed,
then it came in here to the signing phase,
and once they signed, then there’ll be some downstream
activities with their act and manage, once the document
comes back from signature. So Keith, what’s the best
way for developers to get started with Spring? So I encourage anybody who’s
interested in the SpringCM API to first check out
developer.springCM.com. There we have all
kinds of information about what you can do with
the API, a lot of things that I didn’t show in this one. And then when they’re
ready to start coding, to reach out to their
SpringCM representative. Awesome. And are there any jobs available
for engineers in Chicago? Oh yeah, we’re hiring across
our entire technology team. We’re looking for full stack
engineers, UI engineers, QA, operations. So I encourage anybody who’d
like to join us to check out the Docusign job site. Great. Thanks for chatting. Hey, appreciate it. [MUSIC PLAYING]

Leave a Reply

Your email address will not be published. Required fields are marked *