Name: Extending the Application Using Pro-Code in SAP Sales Cloud Version 2
Uploaded: 2024-4-10
Duration: 617 s
Description: This video shows how you can leverage the SAP Cloud Application Programming Model and the SAP Cloud SDK to develop more great extensions.

Share feedback

<p><u><strong>Planned maintenance of Practice Systems</strong></u></p>

Planned maintenance of Practice Systems

Why create an SAP account?

Enhance your learning experience

SAP Learning

Choose your subscription

Manage your subscription

Live Sessions

Hands-on Practice

Certification

My Learning

Ready to start learning?

<div><div><div><div>This video shows how you can leverage the SAP Cloud Application Programming Model and the SAP Cloud SDK to develop more great extensions.</div></div></div></div>

Extending the Application Using Pro-Code in SAP Sales Cloud Version 2

Today we want to take a look how we can extend our SAP Sales Cloud using a ProCode extension. For this we prepared a small use case. Imagine you have a great opportunity in sales. But there are always some risks if you have an opportunity. There might be something like a high price for your products. There might be a very strong competition in your field. Or there might be also some known quality issues. So you would need to have some risks and some mitigations and maybe capture that in your opportunity because that's very important. So you have one opportunity and many different risks. If you want to do that in standard there is no such thing as capturing risks on an opportunity. But hey that's really no problem because we can simply use the extension framework of SAP to extend an opportunity with risks, store them in a database, and also do analytics later on on that data. So let's jump into the architecture before we jump into the use case and show it to you in the solution. So first, we have the SAP Sales Cloud here. Now, in the next step, we would like to use a business technology platform of SAP to extend the SAP Sales Cloud. In our case, our developer will use the Business Application Studio to develop this extension. You could also use this visual code or a no-code, low-code approach, but in this case, we want to do a pro-code extension. He will develop on Cloud Foundry with NodeJS, a backend application, and we use the Fiori Elements for the user interface. We will use the cloud application programming model, which allows us to always generate all the necessary code based on actually a data schema. We will see this later on. This will very much simplify this development and really this can be done as a one developer, the full stack basically, because we really get some tools on the hand that make it much, much easier. Continuing, we use SAP HANA Cloud as our database to persist the data and later merge this also with the data from SAP Sales Cloud to have one common analytics. Now continuing, we will use the Cloud SDK from SAP to directly connect in a standard way to the SAP solutions in this example to the SAP Sales Cloud, but the Cloud SDK can be used to connect any SAP solution very easily and really take a lot of boilerplate coding away from you and make it develop much, much more simple. So with that, the next step would be to deploy our application to the HTML5 application repository on the Business Technology Platform. This we can embed then in a mashup in SAP Sales Cloud. So in the final step, we also have the end user. He would access the application the normal way via his application client, which would be connected to a cloud identity service that both solarizes him to the SAP Sales Cloud as well as to the HTML5 application repository where our extension is stored. And for sure, in our use case, we also don't want to forget about AI. And we will use the AI core of SAP to trigger a prompt to ChatGPT that gives us already some recommendations on mitigations for risk. But now, let's jump into it and take a look at our application, the code, and also SAP Sales Cloud. All right, let's go to our opportunities that we want to extend with risks. So as we said, we want to extend an opportunity with risks. The first thing we need to do is to adapt the layout of our opportunity and add a new tab here. where we would like to insert the risks that a certain opportunity can have. So we create a new tab here, if we give it a name like risks, and then we can already add here a mashup, which is actually allowing us to embedding any other user interface. And that's where we will put the user interface that we developed with the Business Application Studio later on. Let's already add the mashup. I prepared that already. You can give them a name and then provide the link and the parameters to it. In this case, we have the risks extension mashup here. We will not see anything yet because we have not activated and deployed our application at the moment. So that's why the tab is empty. But let's switch to our business technology platform where we have prepared already our project. We just need to start it. So here we go to the services on the business technology platform and open up the SAP Business Application Studio. This is our go-to development environment on the BTP. It doesn't require any setup. We just need to start a virtual machine here, and we are up and running. For sure, you can also use your visual code locally to deploy to Cloud Foundry. But we're using the Business Application Studio because it just makes it easier to have a quick start. So here we have deployed our project already. So we have something here. We have a GitHub where we store this project. And here you can see a schema that we developed where you can see clearly that we have an opportunities header and risks association here that actually links several risks to one opportunity. So we kind of modeled the data model that we need for our use case. And you can see a list of risks here with an assertion to employees and to certain other things, just as the requirements needed. In our case now, let's open the terminal and let's get this project started. Because at the end, we just need to type your CDS watch and this will start our server here and deploy this locally the project. For sure we could also directly deploy to Cloud Foundry, but let's run it now here on the Business Application Studio. It's running also here already like on a web host kind of, and we can just take a quick look at it. So that's the views that are generated. That's all Fiori elements. We didn't do any like handcrafted user interfaces. So you get this very quickly up and running after you have your data scheme. And here we can edit, delete, change risks basically. So now this will also show up here in our risks. If we do a quick refresh, we will see all the risks coming up linked to the opportunity we are currently in basically because you hand over the parameters and load the adequate risks for our current opportunity. And here we can do the same things. And you see it's very, very nicely embedded. The color scheming fits already. It's really completely standard that we did here. And it's a very nice user interface to edit things. It's very responsive also. And here we can now enter, edit, maintain risks for this opportunity. And because everything is stored in SAP HANA Cloud later on, we can for sure also have nice reports that for sure give us all the risks of certain types, maybe for certain opportunities, and let us know when we win or lose an opportunity based on the risks. What is very important now is this list here. This is not just a hard-coded list. this list is coming from the SAP Sales Cloud. So retrieving all these employees, the moment we open the dialog from the REST service that is behind. So we don't duplicate any data. We really go against the Sales Cloud. And now, when we click this button here, we will create a task that is assigned to this employee in the SAP Sales Cloud. So it's really tightly integrated, both writing and reading data from Sales Cloud, and then the user interface is also integrated. It's a quite standard way to do that, because we use the cloud application programming model. Let's look a little bit closer to the code. So you see our model here, what we just discussed. And now if you open the server here, we can also see the logic. So if you go to the risk service JS, we see the business logic that was implemented. And let's take a few examples. For example, here you see the employee reading service. we use the SAP Cloud SDK to read the data in a standard way, which you can see here where we have the API client. And it takes already a lot of boilerplate code away from us, so it's really, really easy to use that in a standard way. And here you see the logic that makes our UI colorful, because after the reading of the data, we will check the risk impact. And it's bigger than 10,000, we will set the criticality. So if you see here, that's the color coding. So also the business logic is really nicely implemented in a kind of event way after read, after write, after an update. And it's kind of a way how many SAP developers know how to write their code. So going further, you see also the employee node where we have a non-persistent node entity in this case here. Because we don't persist the data, we get it on the fly via the Cloud SDK. And also the user interface that you can find here in the app directory. So here we have currently not much because we have only this one user interface, but also that can be very nicely changed because it's generated and it generates us this annotations. And if you need to change something, we don't need to program anything, but we can just set some properties and can easily change. Let's for example, delete this mitigation field. We didn't delete it on the database, but just on the user interface level. If I go back to our risk developments, switch back and forth so that reloads, you can see, whoa, the mitigation is gone. So it was really a very, very simple way to just remove and hide that. We could also set a property hide. So now let's do another thing. Let's set, make the widths a bit longer. Let's make the priority field really, really big because we don't have a lot of space there. So I just set now the widths priority here in this annotation. And you can see the priority got much, much larger. So it's really a matter of annotating and not coding so much. And that makes it really easy to make the standardized applications to really extend our SAP Sales Cloud with a cloud application programming model in a SAP-confirmed way. And that really helps a lot if we are also going to combine, for example, discount developments with S/4HANA or other things. I hope you enjoyed this session about the cloud application programming model and how we can extend with that SAP Sales Cloud.