openSAP

Developing Java-Based Apps on SAP HANA

Cloud Platform
Week 2 Unit 1

00:00:13 Hi, welcome to Week 2 Unit 1 of the openSAP course "Developing Java-Based Apps on SAP
HANA Cloud Platform".In this unit we want to take a look at the JPA model of the ESPM
application
00:00:28 and how we can develop this.This unit will focus on the theory behind this,
00:00:34 and in the next unit we'll then dive into an exercise and introduce the practice behind this.So
first let's have a look at the SAP HANA Cloud Platform, persistence service.
00:00:46 In the first week we already heard a couple of things about SAP HANA: the database we are
using for the ESPM application,
00:00:54 and now for the persistence service that enables such database use on SAP HANA Cloud
Platform.So we get standards-based access to the database via JDBC or JPA 2.0,
00:01:09 and that's exactly what we are using we are using JPA with the ESPM application.In
comparison to JDBC, JPA just gives us much more ability to define much more of the
database interaction in the Java code,
00:01:27 so it's more or less a wrapper, so we have much less to do, and the real database access is
automatically handled by the JPA framework.
00:01:37 So JPA stands for "Java Persistence API".With the persistence service on SAP HANA Cloud
Platform, we also get a choice of the database platform.
00:01:47 So for example we can use the SAP HANA database on productive landscapes.We also have
the SAP ASE database.
00:01:56 And for local development, included with the SDKs we have Apache Derby, which is a very
small and lightweight database that we can use for local deployment and local testing of our
application.
00:02:10 For the database management part, the database is created in your account.So by default
setting in the developer accounts on the trial landscape,
00:02:19 that schema on a HANA shared system is automatically created while the Java server is
established and the application is deployed.
00:02:31 So that's what actually happens in my case.And we could also, for example, create a HANA
MDC database on the trial landscape,
00:02:40 then create a user there, and put in a binding to our application after it's been deployed.But we
did it just by the automatic setting while a HANA shared system is used.
00:02:54 Then we also need to bind the database to the application, and vice versa.So we need to
create a database binding.
00:03:02 In my case again it was handled automatically by the platform.If we used, for example, a
HANA MDC database,
00:03:09 we would have to create this binding additionally by hand.And all the data management is
available in the cockpit we will see this in a minute.
00:03:19 Okay, so now the Java Persistence API I mentioned it already, abbreviated to JPA.It
describes the management of relational data in applications.
00:03:29 So you really can write the classes in the application already, and those are then transferred
automatically into database tables by the framework.
00:03:39 You don't actually have to do this yourself.JPA replaces the persistence solution for EJB
(Enterprise Java Beans) 2.0 CMP.

1
00:03:51 And this is currently the model you should be using if you want all this to be handled by the
framework and you're developing a Java application.
00:04:00 So here EclipseLink is the actual framework for the JPA standard.That's the reference
application, and that's also what comes into play with SAP HANA Cloud Platform.
00:04:12 Because in SAP HANA Cloud Platform we have default support for JPA 2.0, and I'm using this
via EclipseLink in the ESPM application.
00:04:23 Now looking at this unit and the next one, this unit is the theory unit and the next one is then
the practice unit.
00:04:33 What I will focus on in our application is the application architecture.So the ESPM application
runs on a Java server on SAP HANA Cloud Platform,
00:04:43 and it leverages the JPA the Java Persistence API via EclipseLink.We see this here in the
marked layer.
00:04:52 And that JPA layer of the application, or the application is bound with a database binding to an
SAP HANA database also running in SAP HANA Cloud Platform.
00:05:04 So these are the components here.But actually with the database and the database binding
we don't have to do anything here
00:05:10 that's handled automatically by the platform.The real work that we have is writing the JPA
layer, so writing the code for this.
00:05:20 Okay, with this we also have here the JPA model diagram.When we switch to our ESPM
application in the repository on GitHub,
00:05:36 and when you scroll down there, you have the business scenario up there and some setup
instructions, which we covered in Week 1 of this course.
00:05:44 Here we also have the deep-dive architecture, and then also here the JPA class diagram.
00:05:51 So if you want to have a look at this, you can take a look there and also download the
picture.Now here we have the classes that we need for example, the Customer class and
much more.
00:06:04 When we take a look at the code, we also have the diagram.In the code it's specified in XML.

00:06:12 And in our model classes, so in the JPA module, there in the model classes, we also have our
items for which we created the classes with the JPA annotations,
00:06:25 and for which the EclipseLink framework that complies with the JPA 2.0 standard would then
create database tables in the underlying database.
00:06:36 So let's have a look at the code.And here in the code we see either directly in the parent
project,
00:06:46 we can see the diagrams here, and also when we go down here "src", "main", "java", "com",
"sap", "espm", "model"
00:06:55 we see here all the classes, the JPA model classes, that we implemented to make this really
happen.So for example here we have the Customer class.
00:07:06 We have here the customer ID.Above that, we also have the JPA annotations here.
00:07:14 So for example here an annotation for a column.Here we have all the information that is stored
about a customer.
00:07:24 So that's really then implemented in Java together with the JPA annotation, and EclipseLink
then handles this in the background to do the actual communication with the database.
00:07:37 So here that's all the information that we need about a customer.We also have much more
information here.
00:07:44 For example, the next one very important is our products.So those are also stored in the
application.
00:07:50 And also in the database here we have the column name again "PRODUCT_ID" in the table
"ESPM_PRODUCT".
00:07:59 So all this is also contained in the underlying database.Here we also have "resources".
00:08:07 So when we go there... let me zoom in a bit...here under "data" we also have the resources in
XML files.
00:08:21 That is how the products are actually shown in the application when you open it.So those are
deployed with the application.
00:08:32 Then here under "data" we have "DataLoader" and the "XMLParser" classes.We also have
some utility classes with some utility functions.
00:08:45 But here these are really the files that are then taken and put into the database, which you
then see when you open the application.
00:08:55 For example I've got it opened here somewhere.So when we see the Web shop application,
here we can see the products and the product information.
00:09:05 So that information is actually stored in the XML files, deployed with them, then put into the
database, retrieved from there and displayed here.
00:09:14 Here in the database we also have tables for... let's see, for example, here for a sales
order.And those for the sales order are actually empty when we deploy the application.
00:09:29 But when we then create such an order for a product, for example, in the retailer role we can
then see this sales order, and we can accept it or reject it.
00:09:43 And here those items are also stored in the SAP HANA database, and we also have these
classes for them here.
00:09:53 Here we also see a few more classes, some of which we might cover later, like the review
class.But if you want to have a look now, feel free.
00:10:06 So let's close this because this is the parent project but we also have our JPA module.And so
actually these are the classes you can also take a look at the classes here.
00:10:19 Here I would say these are now partitioned in a way that is a bit easier to view.So we have the
JPA content with the "persistence.xml" file.
00:10:29 Here we have the classes, so it's actually the same classes shown in two different ways with
the Maven project.And here we can also take a look at those classes.
00:10:41 Here we have the model data classes with "DataLoader.java".We also have our resources
here.
00:10:49 They're exactly the same parts.Okay, yes, here: "CustomerReviews", "Business_Partners",
"Product_Categories", and "Products".
00:10:57 So with this I hope you got a much better sense of the JPA model of the ESPM
application.Let's go back to the slides.
00:11:11 Yes, what we have here are our diagram and also the classes that really characterize
this.They're really a key point.
00:11:20 In the next unit, as a short preview, we will actually take some of the code here and develop to
learn how we can develop such a JPA model,
00:11:36 which would then also apply not only to the ESPM application, but to all Java applications that
we want to develop.So what have you learned in this unit?
00:11:46 You have learned how Persistence as a Service works on SAP HANA Cloud Platform, so the
SAP HANA Cloud Platform, persistence service.You have learned what the Java Persistence
API, or JPA for short, is.
00:12:02 You have also seen the involved components of the ESPM application for this implementation
part, so for the JPA model part.
00:12:11 And of course you have taken a look at the ESPM application and the JPA model there, looked
around a bit in the code to understand which module and which classes actually make this
JPA model and what they do.
00:12:29 So hopefully you've got a sense of how this works, which we might then apply in the next
unit.Thanks a lot and see you in the next unit.
Week 2 Unit 2

00:00:13 Hi, and welcome to Week 2 Unit 2 of the openSAP course "Developing Java-Based Apps on
SAP HANA Cloud Platform".In this unit we will continue what we began in the previous unit,
00:00:28 so we will again have a look at the JPA model and how we might develop this, but compared
to the previous unit, we will now really go into the hands-on stuff.
00:00:37 So in the previous unit you should have understood what exact classes build up this JPA
model and what they do, and now we will develop some code in those classes.
00:00:52 So first a short recap.In the previous unit we had a look at the JPA model diagram.
00:00:58 So there we see all the classes that make up the JPA model in a very easy way so we can
understand it.And then we also had a look at the code, the actual code classes and Java
classes that make up the JPA model.
00:01:15 I also explained a bit about how they work, and I hope you got a good feel for what happens
there and how you might develop something in that area yourself.
00:01:27 Now, for all those hands-on parts overall, we will now check out a practice branch for the JPA
model,
00:01:38 and with this practice branch, we removed some code snippets from the master branch.And in
a couple of steps and I will show you how to do this your task will now be to develop those
parts of the code.
00:01:54 As additional material, we have also provided a code snippet, or a PDF file with those code
snippets, where you can then find the code you should write.
00:02:05 There are two options here.So you probably want to have a look at the code snippet.
00:02:10 I will also explain what this code snippet does, and then you can copy the code in.Or if you
want to, you can even research in the documentation, perhaps stop the video,
00:02:26 take some minutes, and try to write the code yourself.That's also an option if you're a bit more
advanced and you really want to dig deep, you can of course do this as well.
00:02:36 And then you can also download the one that we provided as additional material and check
whether what you did is the same or at least similar.
00:02:48 So you really get this learning experience.So let's go to Eclipse for a minute,
00:02:57 and what we can also see when we have a look at the project in GitHub is that we have
several branches here.
00:03:05 Up to now we have been using the "master" branch, and now we will check out the
JPA_Exercise branch.
00:03:14 So this is a branch where the project wouldn't work if you just built it because some essential
code parts are missing.
00:03:23 Okay.So in Eclipse, to check out the branch, we go to "Git",
00:03:29 and I've already opened "Branches", "Local" and "Remote Tracking".And we currently have
our "master" branch the local one checked out.
00:03:38 Now we will check out the "JPA_Exercise" branch.And we will check this out as a commit,
00:03:45 because we really don't want to check it out, change stuff, and then check it in again.We just
want to check it out, do some changes, build it, and then deploy it, but we don't want to check
it in again.
00:03:57 So with this we can switch back to the Java EE perspective, and we can already see that in
our code, in our class files, some stuff is not working there are some errors shown.
00:04:11 Okay, so I will just open a couple of those.So we actually see what we will do with the
exercises here.
00:04:23 So... we will have it... soon... okay.So... and we will also need that one.
00:04:39 Perhaps even a bit more, but with this we are on the practice branch.And let's now get into it
with the first hands-on exercise.
00:04:50 So now our job will be to prepare the Web application project for JPA.In order to do this, we
need to go to the "web.xml" file in our Eclipse,
00:05:04 where we will have to insert a code snippet that exactly represents the JPA model and does
that reference.So when you download the additional material, you will find here the code
"Snippet 1",
00:05:19 which is really the reference for the JNDI, JPA model reference.Here we see that "DefaultDB"
is mentioned with the resource name,
00:05:37 and then also here the resource type is our DataSource.Without this, the JPA model wouldn't
work,
00:05:46 but with this stated in the "web.xml" file, we make sure that our JPA model works.So let's copy
the code,
00:06:00 and go to Eclipse, open our "web.xml" file,
00:06:06 scroll down a bit, and here we see the part with the TODO where we need to add this.Just to
make it look a bit better, we can also go to "Source" and "Format",
00:06:22 and with this we have stated our JPA model as the DefaultDB, here our DataSource that
referenced the JPA model as DefaultDB.
00:06:36 We can save this, and our first hands-on exercise is now completed.Let's go to the second
one.
00:06:45 In this one we will have a look at EntityManagerFactory, and we need to write the function that
initializes this EntityManagerFactory.
00:06:58 So again here "JpaEntityManagerFactory.java" is the class file we need to modify.And a code
snippet is also provided here.
00:07:08 So let's first go to the Java class, we have it here.And here it's mentioned to do "Add the
EntitymanagerFactory Method here".
00:07:21 And if we now have a look at the code snippet, it's a bit longer, but let's paste it in first and then
let me explain what it does.
00:07:35 We have this... and...then... this... format this... and save.
00:07:54 Okay, and we already see that a couple of those errors in those other classes are fixed
because they referenced exactly this initialization method of the EntityManagerFactory.
00:08:06 So now what does this method do? We see that it's a static synchronized method,
00:08:15 and it doesn't have parameters here empty and it has two exceptions which it throws.Next,
of course, we first need to check whether there is already an EntityManagerFactory.

00:08:30 So if there isn't one yet, we need to create one, and if there already is one, we will just return it.

00:08:36 So this method is just built as a singleton factory because we need only one of those factories.

00:08:46 How can we create this? So first we create this InitialContext,

00:08:51 second we create the DataSource by looking up the name of the here the DefaultDB
DATA_SOURCE_NAME, which we have as a static string.
00:09:07 And then the properties are put into that map here.And then here we exactly create that
EntityManagerFactory with our properties and again with "PERSISTENCE_UNIT_NAME".
00:09:27 One more thing that we do in the utility class is... we have the setEntityManagerFactory
function which just sets this here.Okay, with this we have also done the second part.
00:09:44 And the JPA EntityManagerFactory is also very important as a class, and of course also the
initial method for enabling our JPA model,
00:09:54 because without this, we wouldn't be able to work with it.Okay, next we have the entity.
00:10:05 So we have a couple of entities, or quite a lot of entities in the JPA model, but we will now look
at one of those entities, and in two steps we will write some code for this entity.
00:10:19 So for the first one, we will go to the "SalesOrderHeader.java" file, and in that file we will insert
here... let's see... our code snippet,
00:10:31 we will declare that as an entity, and then also declare a table for it, so the SalesOrderHeader.
00:10:40 Let's see where this resides."SalesOrderHeader"
00:10:47 And here... we need to put in this code.And we can save it.
00:10:56 So what do those two do? Those two are our JPA annotations.The first one "@Entity" just
declares that this class is an entity,
00:11:08 which is then also shown as an entity in the diagram.The second one states that this class
should be made into a table in the database,
00:11:18 and the table name should be "ESPM_SALES_ORDER_HEADER".The next one, in the same
class file we again have a second code snippet,
00:11:30 and that one is a bit longer, so we have it here.And this one... let me put it in and then explain
it... here.
00:11:49 Okay.Again we can save this.
00:11:55 So what is done with this one? This method, the "persist void" function, has an annotation
"PrePersist".
00:12:06 So this function is executed before the data in the JPA model is persisted in the database.And
what exactly happens here?
00:12:21 So we set a lifeCycleStatus and its name, and here we also have a couple more things.And
here the initial thing is "for" the salesOrderItems,
00:12:35 so we go over here, over all those salesOrderItems.And then we set itemNumbers for them
and their amount.
00:12:46 So really this function is executed before the persistency is done in the database.The next
one, and this will also be the last one for this unit.
00:13:01 So we have the "persistence.xml" file, which is a really important file for a JPA model because
quite a lot of stuff is declared there.
00:13:12 And now we will open that file and insert this code.And...
00:13:28 let me see where we have the "persistence.xml" file it's in "JPA Content".We will just open
the source, and then add this one here.
00:13:41 So what we actually do with that short code snippet is that we say the SalesOrderHeader, the
class we just developed a bit, should be put into the JPA model.
00:13:55 So without this, the JPA model wouldn't really know that this class exists.But with this
declaration here, we say that this class is part of the JPA model and then the class file is
"read".
00:14:09 And also all those JPA annotations in that class file really come into play, and it becomes a
class that will then be persisted in the database via the JPA and EclipseLink framework which
is used here.
00:14:28 Okay, so with this we are coming to the end of this unit.I hope you got a deeper understanding
of how the JPA model works
00:14:40 and how you might develop such a JPA model yourself in your applications.So what did we
actually do in the applications?
00:14:48 So we had a short look back into the previous unit, where we covered the theory behind the
JPA model.Then we got deep into some hands-on stuff where we did some practice exercises.

00:15:04 First we worked with the EntityManagerFactory.So we wrote the initialization method there.
00:15:12 Then we got into some JPA entities, so how we might declare a class file as a JPA entity, how
we can put a JPA annotation in so that this class is also made into a database table,
00:15:28 how we might write a PrePersist function which is executed before the data is stored in the
database.And then we also had a look at the "persistence.xml" file,
00:15:38 where we would really need to declare all of those entity classes, otherwise the JPA model
wouldn't really notice that those classes are there.
00:15:47 Okay, with this, thanks a lot for listening to this, and I hope you enjoyed the exercises.
00:15:53 In this next unit we'll be going into the OData services.Thanks a lot and goodbye.
Week 2 Unit 3

00:00:13 Hi, welcome to Week 2 Unit 3 of the openSAP course "Developing Java-Based Apps on SAP
HANA Cloud Platform".In this unit we will take a look at the OData services in the ESPM
application and also in general in Java applications,
00:00:32 and how we can develop those OData services.In this unit we will focus on the theory behind
this,
00:00:38 and in the next unit we will then go into the practice and actually do some of the development
there.Before diving into the theory, let's have a look at Apache Olingo.
00:00:50 So the Apache Olingo framework is the one we're using to implement those OData services
here.Apache Olingo is a Java library which you can use in your applications.
00:01:03 It implements the Open Data Protocol in short, OData.And with the implementation of them,
you can create OData services with this Java library.
00:01:15 It serves client and server aspects for OData, so we can actually use this on both sides,
00:01:22 so as a server and also as a client.Currently it supports OData 2.0,
00:01:28 but it will also support OData 4.0 when it comes.Okay.
00:01:35 With this I would like to directly dive in.As we heard before, the ESPM application runs on a
Java server.
00:01:46 It exposes the JPA entities as OData services via this Apache Olingo Java library.And here, as
we also see in the architecture, we have two OData services which are exposed.
00:02:01 One is the Web shop OData service, which the customer accesses and is not protected, but
then we also have the retailer OData service, which is a protected resource.
00:02:16 It is then also accessed by the retailer, which is an authenticated and authorized user.We will
also learn more about authentication and authorization next week in the security week of this
course.
00:02:30 The ESPM application also consumes those OData services with the UI layer, with the Web
shop, so from the customer point of view and with the retail applications.
00:02:45 We will have a look at those applications later this week.Now, as marked in the box in the
architecture,
00:02:51 we will really focus in on those parts about the OData service provider, because that's an
important part for the application, and without it, the application wouldn't work.
00:03:06 So what's actually now involved? What classes are involved? And what do they do? Let's have
a look.
00:03:12 So it's in the "espm-cloud-web" module, which we see here on the left-hand side.If we go down
there into "model" and then "web",
00:03:23 we see some implementation classes.For one we see the EspmServiceFactory class,
00:03:31 and the JpaEntityManagerFactory.So those are the factory classes that are needed to
implement the factory for those OData services.
00:03:42 When we have a look at the code and here I've already opened this so I'm currently in the
parent project here, and then you can go into the "espm-cloud-web" module,
00:03:54 go down to "model", and open the "web" folder.The same would also apply here let's zoom in
a bit for the "web" module when you're opening this module directly.
00:04:09 So here, under "Java Resources", you could go to "java", and then here under the "web"
package you would see the same classes.But for now let's have a look at it here, in the parent
project.
00:04:25 So here, first the EspmServiceFactory and the JpaEntityManagerFactory, those are a really
important part in implementing the OData service.
00:04:38 So here we also see that this EspmServiceFactory class uses the JpaEntityManagerFactory
as a persistence part.
00:04:56 Here, when we also go into the JpaEntityManagerFactory, we see here the "DefaultDB" is set
as the data source for those OData services,
00:05:08 and again we also have the "PERSISTENCE_UNIT_NAME".Okay, so next, what's also
important is that we also have some special mappings.
00:05:27 So when we take a look at the "EspmEdmMapping.xml" file here, that is important for mapping
the names of the JPA attributes to some names in the OData service.
00:05:46 So that's actually what this file does here just mapping between those two types.So when we
go back to the right side here and to those classes,
00:06:00 we have the EspmProcessingExtension and then three processors implemented for those
extensions.
00:06:08 The processors are actually functioning parts, which are allowed by the Apache Olingo
library.So by default mapping, you can map CRUD so the set of functions that is defined with
the CRUD operations you can map those directly.
00:06:34 But if you want to do more, you can implement such functions here for this, and then also
register those functions with this extension.And so with this you can write additional operations
that can be accessed by HTTP GET and SET methods.
00:06:57 So what we have here in the processing extensions is just for registering operations.And here,
for example, let's then go into such a processor.
00:07:07 Here we have the EdmFunctionImport, and what actually happens here in the background is
that a real query is created
00:07:21 and executed to get a certain part which we want to expose in the OData service.Okay.
00:07:31 So what else is implemented here? What else is important when we have a look at OData
services?
00:07:38 If we now take a look again at the left-hand side, we have the StartupServlet, also in the "web"
package, which we haven't yet had a look at, so we'll do that right now.
00:07:52 And then we have the "web.xml" file, our standard Java file.That finds quite a lot of information.

00:08:00 And here we also have to do some definitions that we need for our OData services.So going
back into the code...
00:08:10 First the StartupServlet.It's pretty easy it just defines that a DataLoader here is defined in the
StartupServlet,
00:08:21 just to get it all going, let's say.If we then go down into the "WEB-INF" folder and open our
"web.xml" file here,
00:08:33 we also see here directly, as the first part, some parts for the OData service.So here we have
as the first part... no, this one will be important later.
00:08:49 But here we have our OData application registered, and then also the ServiceFactory.And
here is the actual servlet, and the code, the URL pattern is specified here.
00:09:07 Next here we also have a filter class let's see what that is.So if we now take a look at the
right-hand side of the slide,
00:09:17 we have implemented an EspmServiceFactoryFilter class, and then in the "web.xml" file some
corresponding information.
00:09:26 So what's that for? Opening the filter class, we see that it secures something, okay?
00:09:36 In the first part, if you don't have authorization, you are rejected okay, that makes sense.And
we see here that some parts of the application are restricted.
00:09:48 And here that's exactly when we just want to restrict certain parts of the application.We can do
this by here implementing such a... we had it here... such a filter class.
00:10:08 And by implementing such a filter class here and then specifying this filter here in the ESPM
OData service, we can secure some parts of the application.
00:10:23 So we also see it here for the SecureServlet.The implementation that some parts, some
specific URLs are also secured then directly with those classes.
00:10:40 This one here is the default one, but if you want to have it specified a bit more granular, you
can also do it here with such a filter class.
00:10:51 Okay, with this I would say you should have a good overview of the classes.As mentioned
before, when we open the Web module here directly and then go to the Java classes,
00:11:09 we can see the exact same classes here again.We had here our EspmServiceFactory,
00:11:17 we also had the JpaEntityManagerFactory both just make the service work in general.We
had our EspmProcessingExtension, and here the processors for the function imports.
00:11:29 Those are needed to expose more than just the CRUD operations.Here we also had the filter,
which then secures specific parts of the application if we want to have this really granular
definition for this.
00:11:48 Okay, let's zoom out a bit again.Okay, with this I think we've covered most of the classes of the
OData service.
00:11:54 And actually, as a preview of the next unit, what we will do there again is some exercises
where we are developing parts of those OData service implementations
00:12:07 to really see how this works.So what have you learned in this unit and what was its goal?
00:12:13 You got an overview of Apache Olingo, a bit about how the framework works, and what you
can use it for.Then what components are involved in the ESPM application for the OData
provider layer.
00:12:30 And also what classes exactly are important in writing this OData layer, and what you can do
there, and how we did it for the ESPM application.
00:12:41 That's it for this unit.Thanks a lot and see you in the next unit.
Week 2 Unit 4

00:00:13 Hi, and welcome to Week 2 Unit 4 of the openSAP course "Developing Java-Based Apps on
SAP HANA Cloud Platform".In this unit we will continue with the topic from the previous unit,
00:00:28 so with the development of the OData services used in the ESPM application.Compared to the
previous unit we will not focus on the theory, but really on the practice,
00:00:39 so we will dive into some hands-on exercises on how we can develop the OData services in
the ESPM application, and how you might do the same in your Java applications.
00:00:53 With this let's begin with a short recap of the OData services of the ESPM application, which
we had a look at in the previous unit.
00:01:04 So we had a look at the EspmServiceFactory and JpaEntityManagerFactory classes, because
those are really important to first just define the OData services.
00:01:18 The Apache Olingo framework is used for this.Then we also had a look at
EspmProcessingExtension and the processors,
00:01:29 which are the classes for doing more operations than just the simple CRUD operations, but
really provide a bit more.
00:01:41 Then we also had a look at the "web.xml" file, where this is all defined, and at the
StartupServlet, which initializes all of
00:01:51 Next we also had a look at the EspmServiceFactoryFilter and the "web.xml" file again,
00:01:58 because there with this filter we were able to specify certain URL patterns, so really very
specific URLs which should be secured.
00:02:09 Okay, with this let's dive into the hands-on part, And first let's go again to our GitHub project.
00:02:17 So here in the second unit of this week, we've used the "JPA_Exercise" branch.Now we will
use the "OData_Exercise" branch.
00:02:28 And the same when we look at our Eclipse.And there we can now also check out as a commit
the OData_Exercise branch.
00:02:38 Let's do a reset okay, all fine.And with this we are on that OData_Exercise branch.
00:02:49 How we can develop this now.So let's open some of the important classes here we have this
one.
00:02:58 We also have our processors, which are important.Perhaps a couple of others that we might
need later as well.
00:03:07 But for now, let's see what we can do with those.Okay, so what's the first hands-on exercise?

00:03:15 The first hands-on exercise is that we will modify the EspmServiceFactory.java file, and when
we have a look at the code snippets which are provided as additional material,
00:03:29 we can see let me put it in and explain it so this code snippet here,
00:03:37 "EspmServiceFactory", here is the "to-do" part, what it actually does, and let's do this, and then
this.
00:03:48 So with this code snippet here, we first set the ODataJPAContext.Here we use that one.
00:04:01 Then we actually initialize the EntityManagerFactory.So first we get the EntityManagerFactory
from the JpaEntityManagerFactory,
00:04:14 and then here we actually set this ODataJPAContext by doing that stuff in.
00:04:24 Here we also declare the ProcessingExtension.These are all important things.
00:04:30 Also the EdmMapping to map the names which we need in order just to initialize our
EspmServiceFactory.Okay, with this let's see what the error here
00:04:49 Ah, sure, we will see this shortly.So what is the next hands-on part?
00:04:56 The next one is we will define a function import.So in order to do this we will use the
CustomerProcessor, the Java class.
00:05:09 In that CustomerProcessor we will see that... let's just have a look at it...We see here what the
CustomerProcessor does.
00:05:20 So it executes a customer, it executes a query where it selects a number of customers from
our list of customers with a certain e-mail address.
00:05:36 And that's usually one customer with that exact e-mail address.And if it isn't successful, then it
says that there is no matching customer with this e-mail address.
00:05:49 And now to see the code snippet.What the code snippet actually does is that... let's put it in...

00:06:03 so... here.Okay... let's see.

00:06:21 Okay, we have this one, this is fine.And here... we will...
00:06:31 just change that.So what does this actually do?
00:06:42 So here with this @EdmFunctionImport we really define that this
GetCustomerByEmailAddress function is a function import.
00:07:01 And then here we give it a name, we also give it the entity set which is used,
00:07:07 then we give it a ReturnType, which is an entity and might also be a collection.
00:07:17 In the declaration we just state that the EdmFunctionImportParamater is the EmailAddress,
and then the EmailAddress is provided.
00:07:31 Okay, so with this done we might be able to go further on.So here in the next code snippet...
let's first have a look at the slide for it.
00:07:45 So we will go into the EspmProcessingExtension, and there we will register we will see it
here exactly the CustomerProcessor which we just defined.
00:08:03 So I'm going into the EspmProcessingExtension, and then here we need to declare those.
00:08:14 So again without... similar to what we did with the JPA model in the persistence of the XML
file, we had to declare the classes which are used as those JPA entities.
00:08:26 Here again we have to register our processors, our function imports so that they are actually
visible for the OData service and that they are used in the OData service.
00:08:39 Okay, we had a problem here, so let's see what it was.
00:08:48 So we have this.We just don't need this.
00:08:57 We can save this, it should be fine.This is all fine, yes.
00:09:02 And with this we are actually through.And let's see what is missing here to cause the error.
00:09:15 So here the SalesOrderItem.We see that here the SalesOrderHeader is an entity, okay.
00:09:32 And the item... tells us... that it isn't an entity, okay.We would just have to update this, and then
we would be able to build it.
00:09:46 That's actually what we will be doing now, so let's close this.I'll go back to our parent project,
00:09:53 and with this parent project we will first do "Maven", "Update Project...".We will force the
update,
00:10:04 and let's see... let's do it this way.So with this "Update Project..." we fixed our errors.
00:10:17 And now we would be able to build our project, deploy it again, and it should all be working
fine.And so with each of those branches we removed some of the code which is provided as a
code snippet,
00:10:28 or you could really modify it directly, think about what might be necessary to put in.So for
example when we have a look at the EspmProcessingExtension,
00:10:41 here you really see, for example, for the CustomerReviewProcessor how it is registered.And it
would be very easy, so even if you didn't have that CustomerProcess in,
00:10:56 it would be easy to copy the CustomerReviewProcessor.Okay, then have a look at the class
files this one is the CustomerProcessor, the other one is the CustomerReviewProcessor.
00:11:07 So here we would just be able to delete that "Review" part.And actually it would work just fine
because it's the same code as what is provided as a code snippet.
00:11:20 Here with the EdmFunctionImport it would be a bit harder because you would really have to
look up in the Apache Olingo documentation how to define such function imports,
00:11:34 and once you've found that, you could then really get into the mindset of what you would need
to declare to make sure that this function import works.
00:11:51 It's also the same here with the EdmFunctionImportParameter.You can find those annotations
in the Apache Olingo documentation.
00:12:02 This is the library we are using here, but it should be easy to find on the Web.Okay, with this
we are through with our hands- on exercises for the OData services.
00:12:19 Let's do a short recap of what you learned in this unit.First we had a look back at a previous
unit
00:12:27 where we covered the theory behind those OData services, what classes do what, and what
exactly the Apache Olingo framework allows you to do for Odata services.
00:12:41 Next, in this unit, we then did some hands-on practice exercises.First we initialized the
ODataJPAContext, which is really an important part of the application
00:12:55 because without this JPAContext for OData, we wouldn't have our data source put in, so it just
wouldn't work.Next we had a look at the function imports.
00:13:07 We defined the CustomerProcessor function import and then registered that in the
ProcessingExtension.Thanks a lot and see you in the next unit.
Week 2 Unit 5

00:00:12 Hi, and welcome to Week 2 Unit 5 of the openSAP course "Developing Java-Based Apps on
SAP HANA Cloud Platform".In this unit we want to take a look at the SAPUI5 Web application
layer of the ESPM application,
00:00:29 and how we can develop it, as well as how we could develop such a layer for other Java
applications.
00:00:37 In this unit we will focus on the theory behind it and in the next unit we will go into the practice
and do some hands-on exercises on how to develop that stuff.
00:00:50 First, in Week 1 we heard a bit about SAPUI5, what it is, and how it can be used.Now let's go a
bit deeper and take a look at the Model View Controller concept, or MVC in short.
00:01:08 It's a very common concept in front-end applications, and it's also used quite a lot for SAPUI5,
and even encouraged to always use it.
00:01:18 So the goal of the Model View Controller concept in SAPUI5 is to separate the representation
of the information from the user interaction.
00:01:29 So here having the representation on one side, and the real interaction on the other side.This
separation facilitates the development, and also when further maintaining and changing parts
afterwards.
00:01:46 When parts of this change, not everything has to be touched, so with this more modular
structure of the front- end application, we're better able to modify it.
00:01:59 The "view" part, which we also see in the diagram in the bottom right-hand corner, is
responsible for defining and rendering the UI.
00:02:08 So that is really how the information is represented.The "model" on the left-hand side of the
diagram manages the application data,
00:02:18 so how the application data comes up from the back end.We also have the "controller".
00:02:28 The controllers react to triggers, or events from the view, and then they can modify the
view.They really control the user interaction.
00:02:43 And here the controller can also be modified by the model about something, and then in turn it
can modify the model.
00:02:54 So what often happens here is that in the view, so the representation of the information, you
would click on a button, that button would register or throw an event,
00:03:09 which would notify the controller that this button was clicked.And then the controller would
modify the model in the background.
00:03:19 So, for example, because of this button, some item in the ESPM application should be put into
the shopping cart or something like that, then this would be modified in the model,
00:03:34 and in turn the model would notify the controller that something here had changed, and using
the data binding between the model and the view, the model would update the view with the
new information.
00:03:47 So, for example, here with our shopping cart, the number "1" would be displayed besides the
shopping cart.We can also... Let's just take a look at this.
00:03:59 So when we open the ESPM application, and when we click "Add to Cart" here,
00:04:05 we first get this message that this was successfully added to the cart, and here we see the
number "1" next to the cart, so something was added here.
00:04:16 And that's what would actually happen in the background.The view would notify the controller,
the controller would modify the model,
00:04:24 the model would be updated, and with that, the view again would be updated.Okay, but now
which parts of the architecture of the ESPM application are actually involved in this SAPUI5
Web application layer?
00:04:43 So here again the ESPM application runs on a Java server on SAP HANA Cloud Platform, and
it contains two SAPUI5 applications.
00:04:53 We've already had a look at both of those applications.One of them is the Web shop
application, so that's from the customer point of view.
00:05:03 And the second one is the retailer application, with a retailer who is then authenticated and
authorized to do some special interactions,
00:05:13 such as accepting or rejecting a sales order, as well as updating the stock information.And
here, that UI layer for both applications accesses the data through OData services,
00:05:28 which we also saw and developed parts of previously, so now we are really focusing on that
top front- end layer of the SAPUI5 Web application part.
00:05:43 Okay.So now what actual classes are involved, where can we find them, and what do they do?

00:05:49 Here, on the left-hand side of the slide, you can see the view, the model, and the controller,
which I've marked.So those three are already explained in the MVC concept.
00:06:02 So those folders are really important, and the classes there.And in a minute we'll also see that
they have classes for the same types.
00:06:13 Here too is the "manifest.json" file.That is important for all SAPUI5 applications because it
specifies the rules, for example how the navigation works in the application.
00:06:29 So let's switch to our Eclipse.I've already opened this, so I'm here in the parent project, ESPM.

00:06:37 Then open "espm-cloud-web"."src", "main", "webapp", and then "webshop".

00:06:44 So let's first have a look at the Web shop, and then let's have a look at the retailer.So here we
see "controller".
00:06:53 We also see the controller classes, and we see "model", the model classes, and "view".So the
first thing that's important here when we see "controller" and "view"
00:07:09 is that really, for example, the shopping cart has a part in "view" and also part in "controller".
00:07:19 And that's actually very common with the MVC concept: You have one class in "view", and a
class with the same or a very similar name in "controller".
00:07:32 So they really correspond together.So one is for how the information is displayed to the user,

00:07:37 and then the second one the controller handles the user interaction for that view.Here, with
SAPUI5, there are a couple of different ways in which we can write those views.
00:07:53 But the most common one is in XML, so that's also what is used here.It's a bit specific to
SAPUI5,
00:08:04 but most examples you find on the Internet are also written in XML, and it's actually the
preferred method for writing SAPUI5 applications.
00:08:14 But also if you know HTML5 and you know XML in general, it shouldn't be that difficult for you
to see how it works and to understand it.
00:08:24 So now I'll open the shopping cart, And here we see, for example, some columns defined, we
see a table defined,
00:08:35 so pretty easy stuff for any Web developer for defining a UI.Here we also see some reference
to the "i18n" folder and the file there.
00:08:53 "i18n" is also a folder that all the SAPUI5 applications contain, and that one contains one or
more properties files.
00:09:06 So those properties files again specify in a certain language the information, the text that is
then displayed in your application.So here in the actual views, we just have the reference to
the "i18n" properties file.
00:09:27 And then in the properties file, we have for one language one properties file where this is
specified.In later units we will also see how we might be able to create several properties files,

00:09:42 and with this have our application very easily displayed in several languages.So here also
separation of just taking all the text that contains the language,
00:09:53 taking this out of the view and putting it in a properties file to really be able to modify this even
more easily without having to touch every view.
00:10:08 So here when we then open, for example, the shopping cart controller, we also see here a
jQuery reference, which should be familiar to every JavaScript developer.
00:10:23 It's also a very important library for JavaScript, and I believe jQuery is the most used jQuery
library overall.And here we also see some functions that are defined for this shopping cart
00:10:41 which are executed, for example, with the navigation, with changes that occur when the user
does certain clicks in the view, and then the functions that are actually happening here in the
controller.
00:10:59 Okay, so let's also have a short look at the model.The model is much shorter, and the folder
contains much less information,
00:11:09 because here the important thing is that there is an automatic binding that binds the model to
the view, and in our case we have a JSON model, so this is handled very easily.
00:11:29 Okay.We can also have a short look at the "manifest.json" file.
00:11:34 Here, for example, we see the defined properties file.We also see the application version.
00:11:42 We also see here that the data source is defined it's the espmDataModel.Here we also see
the URL to the OData service, and the OData version that is used by this application.
00:12:00 Here we also see a reference to the SourceTemplate, so here a UI5 template is used in a
certain version.
00:12:11 Here we also see the UI5 themes that are used, and also supported device types.
00:12:19 We've already seen in the first week that we can also display the application automatically on a
mobile device, and the UI also fits very well on a mobile device,
00:12:32 so it automatically changes the UI a bit on the device's screen size that you have.Here we
have also defined the router and some routing details.
00:12:42 So how you navigate from one page to the next is also handled here in the "manifest.json"
file.Just having a short look here too, on the right- hand side I opened "retailer",
00:13:00 and when we dive into this here... let's see... "webapp", "retailer", we again see "controller".We
see "model", we see "view", we also have our "manifest.json" file.
00:13:18 Perhaps here we also have the "i18n" file.Let's perhaps explain the "css" folder here.
00:13:28 In this sheet you could define specific styles, but we didn't need this for these
applications.There are also some images here that you can put into there.
00:13:46 Also when we have a look like...Every Web application has this "index.html" file, which is just
the entry point of the file.
00:13:56 It defines the border around everything, but what we actually see here is the script for the
SAPUI5 libraries, for the SAPUI5 bootstrap,
00:14:08 and also where the SAPUI5 core resides, and what is actually used from the SAPUI5 libraries.

00:14:18 Okay, so with this I hope you've got a good understanding of what is involved here in the
ESPM application of SAPUI5, in the Web application.
00:14:30 Also you can make use of this information for all your applications which you are
developing.So here in our case we have this UI written in SAPUI5, in the Fiori style, so with the
Fiori design language.
00:14:47 With this we can really write a very user experience-friendly UI that is perfectly displayed on
any device size.And then we use the OData services provided from the back end via Apache
Olingo to provide data to this UI.
00:15:09 And the SAPUI5 application is embedded in our Java application.Okay.
00:15:15 So with this let's go back.And in the next unit, as a short preview, we will focus on the practice
part for the SAPUI5 Web application,
00:15:26 so we will really learn, we will do some exercises on how to develop this part of the application,
to really see what is necessary there.
00:15:37 And now we've got an overview, in the next unit we'll do a bit of hands-on stuff.So what have
you learned in this unit?
00:15:45 In this unit you have learned the Model View Controller (MVC) concept.It's very common and
always used in SAPUI5 applications.
00:15:55 You have also seen the involved components of the ESPM application for this implementation
part, so here for the Web application.
00:16:04 And then we also looked at the classes, the packages, and where everything that's involved
here with the Web application resides.
00:16:12 So thanks a lot and see you in the next unit.Goodbye.
Week 2 Unit 6

00:00:13 Hi, and welcome to Week 2 Unit 6 of the openSAP course "Developing Java-Based Apps on
SAP HANA Cloud Platform".In this unit we will take a look at the SAPUI5 Web application, how
we might develop it in the ESPM application,
00:00:31 and also how you might develop such a SAPUI5 Web application in your own Java project or
even more for all SAPUI5 applications.In this unit, compared to the previous unit, we'll focus on
the practical side of this,
00:00:46 so really going deep into some hands-on exercises where you need to develop some
code.Let's first do a recap of what we covered in the previous unit.
00:01:00 We covered the theory behind those SAPUI5 Web applications.Also with the MVC (Model
View Controller) concept how this is implemented in such SAPUI5 Web applications and
what it does.
00:01:15 And I hope you really got a feeling for and understanding of what the folders and all the
classes in the folders are for and what they do.We had a look at the controller, model, and
view of the Web application and also of the retailer application:
00:01:34 those two SAPUI5 applications which are packaged in our ESPM Java project.Then we also
had a look at the "manifest.json" file.
00:01:49 We haven't really had a look at the "Component.js" file yet, but we will have a look at that in
this unit.The "manifest.json" file there is really important for defining the roles, data sources,
and so on,
00:02:02 as well as the view for handling the representation of the UI, the controllers for handling the
interaction with the UI, and the model for really exposing the data to that UI.
00:02:17 With this let's dive into the hands-on exercises.We have again prepared an exercise branch for
this,
00:02:25 so just choose the SAPUI5_Exercise branch.In that exercise branch, compared to some
previous units, we again excluded, or removed some code snippets
00:02:38 and provided those for you as additional material, so please download them.Here they are in
that file.
00:02:48 If you want to, you can also just use the slides, follow me, and then perhaps stop the video,
think about for yourself what would be the code that you would put in there,
00:03:01 perhaps look it up in documentation or search for it at least, and then continue the video and
see what I do to make it actually work.
00:03:14 So here, in the first one, we will have a look at the "manifest.json" file.And in our clips we again
have to get this exercise branch,
00:03:25 so now we are with the SAPUI5_Exercise.We do a Checkout Commit, reset our previous stuff,
okay, that's fine.
00:03:36 Now we are on that SAPUI5_Exercise branch.We'll only be needing the Web project here, and
most important for us are those... let's see, we have it here...
00:03:52 No, actually we don't we have it here.So with "webapp" here... we have those two webapps...

00:04:02 Now we will focus on the Webshop.We had it here "webapp" then "webshop".
00:04:09 And the first file we will have a look at is the "manifest.json" file.Okay, here is also where this
code is missing.
00:04:18 And what do we actually do to make it work What is actually missing?
00:04:25 So if we don't look at the additional material or just don't want to download it, we could also
have a look at the master branch.
00:04:37 So I'm just going to the GitHub project, selecting the master branch, and in that master branch
I'm going into the "espm-cloud-web" folder,
00:04:46 and let's see: "main", "webapp", "webshop", and then here the "manifest.json" file.
00:04:55 And directly in our browser, we would be able to see what is missing.So compared to here,
what is missing are our data source declarations.
00:05:05 Okay, so what do they actually do? So here we first declare a data source.
00:05:12 Then we declare the espmDataModel as this data source.We define the URI to that OData
service which we are using as a data source.
00:05:24 Then the type, "OData", and the settings, our "odataVersion".Okay, so with this let's get this
code snippet data source declaration and let's put it into the code.
00:05:41 Okay, with this we have defined our data source, and we can go on to the next hands-on
exercise.
00:05:51 In the next hands-on exercise we will create the main shell for the SAPUI5 app of the
Webshop.So actually what is this main shell and what does it do?
00:06:02 The main shell gives you, let's say, boundaries behind everything.So you need this to then do
the navigation inside the main shell.
00:06:12 So here in the "index.html" file, let's open this We can also... let's format this a bit.
00:06:26 Okay, already done.So what do we need to insert here?
00:06:32 So looking at this one, we have here our SAPUI5 stuff.And... let's see...
00:06:50 Okay, we had it here.In "webshop", we are already... here it is.
00:06:58 I opened the wrong "index.html" file that one was actually for the whole "webapp".Actually
here it is for the Webshop application.
00:07:10 And let's put it in.So what does the script do?
00:07:16 Let's close this one.Previously we have defined our SAPUI5 libraries
00:07:30 and the theme which we are using, the Blue Crystal theme, and with this we attach an
initializer,
00:07:40 so here a function which creates a new shell, and here the height of it is 100% and we give it
the name "com.sap.espm.shop".
00:07:55 And we then place that shell at "content".Okay.
00:08:02 With this let's go to the next part.Here we will be looking at the "Component.js" (JavaScript)
file.
00:08:10 And what is missing there is that we need to set all those models.Okay.
00:08:20 So let's go into the "Component.js" file.And here those models are missing.
00:08:29 So here we have the initializer function.First we apply the arguments that we have here.
00:08:39 Lastly we get the router.And in the middle we have to put in the code to declare the data
sources.
00:08:50 Now we have it.So in first one not to declare the data sources, but a model which uses the
data sources.
00:08:59 So here we first set a model, so we create a device model and set it here.Next here we set the
ServiceUrl of our... here we have the espmDataModel, our data source, and the URI which we
are setting here.
00:09:24 Then next the oEspmModel, which we put in here.And we also configure it as a JSON model
and set this here.
00:09:40 And here our shopping cart is also initialized.And then here lastly we set this JSONModel with
our cart as the JSON model.
00:09:52 So with this we initialize first the device model, then second the OData model,
00:09:58 and lastly the JSON model.So all those models are necessary here for our application,
00:10:04 and so obviously you always have some model in your application, it depends sometimes,
00:10:12 but as we have it here, it's quite often the case.So with this it would all be okay again.
00:10:22 We would have fixed our code, we could update a project, but actually I don't see any errors
now,
00:10:28 so updating the Maven project might be just for customer reasons.Then we could build the
project again, we could deploy the project again, have a look at it,
00:10:44 and see whether everything is actually working fine.And perhaps also we might now... so let's
go into the project... we have it here...
00:11:00 And then let's go in here.So I've already deployed a project,
00:11:08 and with this let's directly use the account URL to navigate to our project.And with this we can
then have a look at it.
00:11:22 And now you perhaps might even see some, let's say, code snippets or such like at least in
the UI which you just modified put in.
00:11:32 So that you really get a better understanding of and a better feel for how this all works.Okay,
so this is currently not loading up.
00:11:43 Let's see, it should be there any minute.Okay, with this let's... check this one... okay.
00:12:08 Okay, also looking into the code that we've now imported, we had a look at the json.js file.
00:12:18 Before that we looked at the "index.html" file.And now looking at the "index.html" files in our
classes,
00:12:26 we have one of those "index.html" files here on the "webshop" application.We have another
one in the "retailer" application.
00:12:36 And we also have one in the "webapp" project.And so actually we see that the "web.xml" file is
only available in the "WEB-INF" file,
00:12:47 so here in the "webapp" folder overall, in the subfolder "WEB-INF", so we have only one of
those "web.xml" files.
00:12:56 But actually we have three of the "index.html" files.Two for each of the Webshops, two for our
front- end apps, and then one for the overall app.
00:13:13 Okay, now that was fine.Let's get into it and...
00:13:21 we see here that we have an announcement something new about the Web IDEs
available.Okay, we can take that link...
00:13:31 and get into it here.So our Webshop application with our products.
00:13:42 You might see here that overall we have our main container.So the one that we put in here,
our main shell we have that one here.
00:13:58 And actually as the data model so here we defined our various data models those are
necessary to handle all that here, to handle our shopping cart, to handle our products here, to
make all that possible.
00:14:16 With this let's go to the last slide.So what have we actually done now in this unit, and what
have done this week?
00:14:26 So we first had a look at the JPA model, then at the OData service,
00:14:35 and in this unit, in the previous one at the SAPUI5 Web application, we first covered them in
the theory, and then we covered them with some hands-on exercises.
00:14:47 And in this unit we had a short recap of the Web application from the last unit, and then did
three exercises:
00:14:56 one to define the data sources in the "manifest.json" file, to create this main shell, which is just
a boundary
00:15:05 and gives all that it sends of our Webshop application of course the retailer application has
one as well and lastly we initialized the component with our various models that we need
here with our
00:15:22 device model, our OData model, and our JSON model.Thanks a lot and see you next week.
 www.sap.com

2016 SAP SE or an SAP affiliate company. All rights reserved.

No part of this publication may be reproduced or transmitted in any form
or for any purpose without the express permission of SAP SE or an SAP
affiliate company.
SAP and other SAP products and services mentioned herein as well as their
respective logos are trademarks or registered trademarks of SAP SE (or an
SAP affiliate company) in Germany and other countries. Please see
http://www.sap.com/corporate-en/legal/copyright/index.epx#trademark for
additional trademark information and notices. Some software products
marketed by SAP SE and its distributors contain proprietary software
components of other software vendors.
National product specifications may vary.
These materials are provided by SAP SE or an SAP affiliate company for
informational purposes only, without representation or warranty of any kind,
and SAP SE or its affiliated companies shall not be liable for errors or
omissions with respect to the materials. The only warranties for SAP SE or
SAP affiliate company products and services are those that are set forth in
the express warranty statements accompanying such products and services,
if any. Nothing herein should be construed as constituting an additional
warranty.
In particular, SAP SE or its affiliated companies have no obligation to pursue
any course of business outlined in this document or any related presentation,
or to develop or release any functionality mentioned therein. This document,
or any related presentation, and SAP SEs or its affiliated companies
strategy and possible future developments, products, and/or platform
directions and functionality are all subject to change and may be changed by
SAP SE or its affiliated companies at any time for any reason without notice.
The information in this document is not a commitment, promise, or legal
obligation to deliver any material, code, or functionality. All forward-looking
statements are subject to various risks and uncertainties that could cause
actual results to differ materially from expectations. Readers are cautioned
not to place undue reliance on these forward-looking statements, which
speak only as of their dates, and they should not be relied upon in making
purchasing decisions.