Script: Recycling-Heroes - Software Components [009]

Introduction 

In this episode, we'll take a look at the ABAP Cloud theory of software components and create the software components and structure in the system to slowly begin working for the Recycling-Heroes company. At the end, we'll synchronize all packages with the GitHub repository. 

Theory

We've already described how software components work and interact with each other in a previous ABAP Cloud article. Here you can find the complete theory again. You can also find a link to the article in the video description. In software component theory, we assume that we don't do all development in one package, but rather structure functions and applications according to different components. These components include, for example, the various apps, interfaces, Fiori deployments, test components, and released components. This makes it immediately clear what I can find where in the software component when I start analyzing it or want to get an overview of a software component. The lower part of the article describes exactly what the different packages do. There you'll find further information on why we want to keep the different components separate from each other.

Let's first look at all the software components we want to create. We'll create one software component for the core and one for the process. Most of the processes are contained there. Another component for the entire topic of finance, since we want to separate the finance area from the process area. In between, you'll find the various packages for the applications we're planning. An application can be a Fiori, a business configuration, or an application job. We also define the various packages for the tests, reusable components, and so on.

Software Component

Next, we'll take care of creating the packages in the system. To do this, we first need three software components that should reflect our structure. To create the software components, we can access the Launchpad via the system and the corresponding properties. Under the ABAP Development area, you'll find the link to the system's Launchpad as we are working on an ABAP Environment. There, we go to the Administration area and the "Manage Software Components" app. There, we filter for the software components that don't currently exist. Using the "Create" button, we can create a new software component. We give it a name and a description, and then we create the component. To make the software component available in the system, we need to clone it. Cloning creates the corresponding transport route and structure package in the system. We'll now perform this process for the process component. The majority of the applications and processes we will implement later should be located in the process. Let's perform the cloning here as well. Depending on the system, it may take a few seconds for the component to be cloned. Finally, we create the last software component, which is intended for finances. Before we leave the app, we get an overview of all three components.

Packages

Once all three software components have been created, we can return to the system. Now we add the created packages to our favorites. To do this, we can go to the "Favorite Packages" folder and right-click to search for a package using the context menu. Using the ZRH abbreviation, we find the corresponding structure packages that were generated in the system.

Next, we create the subpackages in the Core area. The structure of the packages is always relatively similar. At the first level, you'll find the rough subdivision of the packages, for example, App for all applications, jobs, and business configurations that we build. There's a Fiori package for this. In the Fiori package, we would normally deploy the application later, but also create things like IAM apps and business catalogs. In the Reuse area, we find components that are shared between the various applications but are generally not released across software components. The shared package will later contain components that we will assign a C1 contract to and release to other software components. In the test package, you will find corresponding unit tests and test components that were not developed directly on an object, such as unit tests for Core Data Services or the call to individual functions. Finally, we will create the various applications in the app package that we want to build later. Here's a teaser that the number of applications may still change.

Once we've finished with the core module, we'll take care of creating the process. Here, we'll create similar packages as we did for the core. The main difference here is the package of applications and apps. Since we provide other applications here, and these are even larger, it's important to understand again that a separate transport is required for each software component. Behind the software component lies its own transport layer and Git repository, and the objects therefore cannot be transported in one transport. This is different on-premises and primarily affects the ABAP environment we're working on here.

In the third and final step, we create the Finance area. Here, there are the standard packages again, but, for example, no shared package, but instead a package for interfaces. Interfaces to other systems or services are planned later to enable integration.

Git

Once we've finished creating the packages, we can backup everything via GitHub. To do this, we first create three new repositories in GitHub. You can learn how to create a repository in another YouTube video of ours about integrating abapGit. You can find a link to the video in the video description below or on our channel.

In this case, we'll define the repository as private, since we don't want to make it visible to other GitHub users for the time being. Once again, initialization via the README file and a descriptive description are important. We then switch to the ABAP Development Tools and link the repositories to the corresponding packages we created. After linking, we can synchronize the objects to the repository. This way, you can follow every change we make with the tutorials and track the progress in the various commits.

Finally, we'll check Github to see if the corresponding package structures have arrived and are reflected in the repository.

Outlook

In the next video, we'll begin creating the first part of the data model and the first application, which we'll examine in more detail step by step.

Thanks for watching, and see you next time.

YouTube:
Video