Sap Se

Sap Ag

Oliver Klemenz

Ulrich Bestfleisch

Sergey Smirnov

Tim Philipp Trabold

Udo Peter Klein

Sebastian Schroetel

Veit Spaegele

Peter Eberlein

Gregor Karl Frey

Daniel Goldmann

Andreas Mueller

Lu Zhao

Diego Ricardo Rapela

Uwe Schulz

Anna Kabala

The present disclosure involves systems, software, and computer implemented methods for managing and replaying persistent draft messages for entity data. One example method includes receiving a request from a client to read entity data in a draft of an entity. Previously-generated messages for the draft of the entity are retrieved and regenerated. A request to change a field of the entity is received and a set of previously-generated messages that correspond to the field is identified. Each message in the set of previously-generated messages is marked as invalid to prevent subsequent regeneration of messages in the set of messages. Each message in the previously-generated messages that is not marked as invalid is stored as a persistent draft message for the draft of the entity.

Managing and replaying persistent draft messages for entity data

Some embodiments provide a non-transitory machine-readable medium that stores a program. The program receives, from a client device, a request to execute an application object configured to execute in a first runtime environment. The program further registers the first runtime environment in a second runtime environment. The program also registers the application object in the first runtime environment. The program further enriches a definition of the application object with metadata associated with the second runtime environment. The program also executes the application object in the first runtime environment.

Runtime execution of entities and services in an application object runtime environment

Some embodiments provide a non-transitory machine-readable medium that stores a program. The program receives a data model definition defined using a human-readable syntax. The data model definition includes a set of annotated entity definitions. The program further generates a machine-readable representation of the data model definition. Based on the data model definition, the program also generates, for each annotated entity definition in the set of annotated entity definitions, an interface and an implementation class from the machine-readable representation of the data model definition. The program further provides the set of interfaces and the set of implementation classes to an integrated development environment (IDE) application for design-time implementation of the set of interfaces and the set of implementation classes.

Generating interfaces from annotated entity definitions for developing applications

Some embodiments provide a non-transitory machine-readable medium that stores a program. The program receives a data model definition defined using a human-readable syntax. The program further generates a machine-readable representation of the data model definition. Based on the data model definition, the program also generates a set of interfaces from the machine-readable representation of the data model definition. Each interface in the set of interfaces includes code specified in a programming language. The program further provides the set of interfaces to an integrated development environment (IDE) application for design-time implementation of the set of interfaces.

Generating interfaces from data and service definitions for developing applications

Entity-based service operation upon object-based persistence, is efficiently accomplished utilizing mapping between entities and stored objects. An engine within the persistence layer receives a service call referencing an interface entity. The engine determines a context of a core object in the persistence layer. Based upon the context, the engine constructs from the core object, a prepared object including an entity node. A path between the entity node and a root node of the prepared object may comprise context, or may be derived from only partially reading the core object to construct the prepared object. The engine enriches the entity node with entity data from the service call, to generate an applied object. Referencing the applied object as a parameter, the engine executes the service call on the core object. The engine maps the core object to a result object returned to the interface layer in response to the service call.

Entity-based service operation for object-based persistence

Integrity of a physical object is verified by receiving, data encapsulating a request to verify the integrity of the physical object. Subsequently, a data structure is accessed that includes a plurality of linked segments each characterizing an entity within a supply chain for the physical object. Each segment includes a respective predecessor field and a respective hash value. All of the segments can be iterated through in reverse chronological order to confirm, for each segment, whether a value for the predecessor field is equal to a hash value in a hash field in an immediately previously segment, the hash value being a hash of all values of the particular segment. Data characterizing the iteration can then be provided. Related apparatus, systems, techniques and articles are also described.

Cross-system object tracking platform

A persistent library bundle (PLB) is added as a library of an application. The PLB is automatically downloaded from a central registry and installed in an application directory. The PLB provides an out-of-the-box functionality to the application. The PLB includes a PLB persistence description. The PLB persistence description specifies how runtime data of the PLB has to be persisted. Upon installation of the PLB to the application, the PLB persistence description is copied to an application database directory. The application database directory stores application persistence description and the PLB persistence description. The application persistence description and the PLB persistence description are assigned to a certain database schema.

Consuming persistent library bundles

A database system for representing data in an external dataset may include a multidimensional database defined by a set of dimensions associated with a respective set of attributes of the data in the external dataset. The multidimensional database may include a set of cells partitioned or otherwise divided into a set of slots. Each slot may be associated with a set of attribute values of the attribute associated with its corresponding dimension. Each cell may store data from the external dataset accessed by aggregating sets of attribute values associated with respective slots of the dimensions of the multidimensional database that define the cell.

Aggregation database for external dataset

A computing device hosts a graphical user interface (GUI) of a computer application, the computer application being run on a backend computing platform accessible to the computing device via a network. The GUI includes multiple models in a Model-View-Controller (MVC) pattern, an eventing mechanism, and a model synchronizer. Each model in the GUI represents one or more application objects of the computer application. The eventing mechanism generates an application object change event when an application object of one of the multiple models in the GUI is changed to a new state. The model synchronizer listens to the generated application object change event, retrieves the new state of the application object, and locally updates other models of the multiple models in the GUI that also represent the application object with the new state of the application object.

Graphical user interface with consistent redundant models

An application object framework provides a GUI developer with application object metadata that can be leveraged to design and implement GUI controls in an efficient, standardized, straightforward manner. For example, a smart control interface may be utilized that enables linking of a particular GUI control with a corresponding application object, including linking to the application data and logic, through the use of metadata of the corresponding application object. In this way, validations and GUI logic required by the GUI control may be provided automatically, leaving the GUI developer the freedom to focus on the visual composition, functionality, and other desired aspects of the GUI controls.

Smart controls for user interface design and implementation

Disclosed herein are system, method, and computer program product embodiments for automatically integrating different software applications in a cloud platform. An embodiment operates by creating a registration entry representing an integration use-case for a first tenant of a first application in an integration discovery service. The embodiment generates a barcode based on the registration entry. The embodiment matches the integration use-case for the first tenant of the first application with a potential integration use-case for a second tenant of a second application based on the barcode. The embodiment then creates an integration configuration for enabling the integration use-case for the first tenant of the first application with the potential integration use-case for the second tenant of the second application based on the matching.

Automatically integrating applications via an integration discovery service

An application object framework provides a developer with an ability to provide customers with an ability to add custom extension data and an associated generic extension mechanism(s). Accordingly, each customer may be provided with an ability, e.g., to use its own data structures and data definitions to define desired data, and support persistence and process integration thereof. Further, each customer may be enabled to make such extension data available on a corresponding graphical user interface (GUI), e.g., including read/write access using the GUI, in a manner defined by each customer.

Extensibility support for an application object framework

An application object framework provides a software developer with an ability to configure protocol extensions to the application object framework. The software developer may be enabled to configure protocol extensions to the application object framework that enable network communications using protocols that were not originally designed for use by the application object framework, or that did not exist at a time of creation or purchase of the application object framework.

Protocol extensibility for an application object framework

An application object framework enables simultaneous, bi-directional communications between one or more application objects and a client(s) providing a user interface, which may be executing an instance of one or more of the application objects. The application object framework enables an efficient and customized use of existing or newly-created network communications protocols, to provide simultaneous, bi-directional communications that are easily customized to the semantics, actions, and other aspects of application objects.

Bi-directional communication for an application object framework

A method for internationalization of a computer application being designed and developed as cloud application in a platform-as-a-service (PaaS) environment includes disposing a translatable texts table in a data layer of the computer application as a common source of translatable texts for all layers of the computer application. The method further includes disposing a text string translation service in a logic layer of the computer application. to expose the translatable texts table disposed in the data layer to a presentation layer of the computer application.

Growing community of inventors

Sinsheim, Germany

Oliver Klemenz