WO2018134680A1

WO2018134680A1 - System and method for integrating disparate computer systems and applications

Info

Publication number: WO2018134680A1
Application number: PCT/IB2018/000084
Authority: WO
Inventors: Zyrus KHAMBATTA
Original assignee: Clough Ltd
Current assignee: Clough Ltd
Priority date: 2017-01-17
Filing date: 2018-01-17
Publication date: 2018-07-26
Anticipated expiration: 2019-07-17

Abstract

A federated system and method for integrating disparate software and hardware systems to be used in integrating various client computer systems, through the use of adapters storing datasets and mapping identifiers to interact with applications to perform the service request. The adapters can include JSON configuration files or APIs. Used to interact with applications for ERP, HRM, planning and scheduling.

Description

SYSTEM AND METHOD FOR INTEGRATING DISPARATE COMPUTER

SYSTEMS AND APPLICATIONS

RELATED APPLICATIONS

This Application claims priority under 35 U.S.C. § 119(e) to U.S. Provisional Application Serial No. 62/447,284 entitled "SYSTEM AND METHOD FOR MANAGING WORKPLACE FUNCTIONS" filed on January 17, 2017, which is herein incorporated by reference in its entirety.

BACKGROUND

A service provider may interact with several different clients. For example, a construction contracting company may work various construction projects for various different clients. To interact with the different clients, the service provider may use a computer system that is to communicate with various client computer systems. For example, a construction contracting company may manage tasks associated with a client's construction project via communications between the construction company's computer system and the client computer system. Different client computer systems may use different applications for various tasks. The tasks may include, for example, managing project progress and/or tracking time spent on a project. A first client may use a first application for managing a task while a second client may use a different second application for managing the same task. For example, the first client may use the first application for project progress management while the second client may use the second application for project progress management.

Accordingly, a computer system of the service provider often communicates with multiple client computer systems employing disparate applications.

SUMMARY

The inventors have recognized and appreciated that conventional service provider computer systems do not efficiently and effectively communicate with client computer systems using disparate software applications. For example, conventional systems may develop, store, and maintain a separate application for each project and/or client in order to communicate with each of the different client computer systems. Further, conventional systems are unable to concurrently execute services requiring interaction with multiple client computer systems that use disparate applications. To address these problems, the inventors have new developed systems and techniques that allow a service provider computer system to efficiently and concurrently interact with multiple client computer systems that use disparate applications. These new systems and techniques significantly reduce the amount of applications that a service provider must develop, maintain, and store. Furthermore, the systems and techniques adapt services for disparate applications to allow for concurrent performance of services that involve interaction with disparate applications.

According to one aspect, a system for interacting with a plurality of computer systems using disparate applications is provided. The system comprises at least one processor operatively connected to a memory; and an adapter component, executed by the at least one processor, configured to: store, in a dataset, a mapping of a service to a plurality of adaptive functions, each of the plurality of adaptive functions configured to interact with at least one of the disparate application; perform the service for a first project associated with a first client computer system using a first application, the performing comprising: determining, based on an identity of the first project, to execute a first one of the plurality of adaptive functions configured to interact with the first application; triggering execution of the determined first adaptive function; and in response to triggering execution of the first adaptive function, causing interaction with the first client computer system to perform the service.

According to one embodiment, the adapter component is further configured to perform the service for a second project associated with a second client computer system using a second application, the performing comprising: determining, based on an identity of the second project, to execute a second one of the plurality of adaptive functions configured to interact with the second application; causing execution of the determined second adaptive function; and in response to causing the execution of the second adaptive function, interacting with the second client computer system to perform the service.

According to one embodiment, the adapter component is further configured to perform the service for a second project associated with a second client computer system employing the first application, the performing comprising: determining, based on an identity of the second project, to execute the first adaptive function configured to interact with the first client application; causing execution of the first adaptive function; and in response to causing execution of the first adaptive function, interacting with the first application to perform the service.

According to one embodiment, the adapter component is further configured to store, in the dataset, a mapping of an identifier of the first project to an identifier of the first adaptive function configured to interact with the first application to perform the service. According to one embodiment, the adapter component is configured to store, in the data set, a JSON configuration file specifying project specific configuration data associated with the first project to allow the adapter component to connect to the first client computer system to perform the service. According to one embodiment, determining to execute the first one of the plurality of adaptive functions comprises determining to execute the first adaptive function in response to identifying the mapping of the identifier of the first project to the identifier of the first adaptive function.

According to one embodiment, the adapter component is configured to interact with a plurality of different ones of one or more of enterprise resource planning (ERP), human resources management (HRM), partner relation management (PRM), planning, or scheduling applications via the plurality of adaptive functions.

According to one embodiment, the adapter component is further configured to perform the service for the first and second projects in response to a request to perform an aggregation operation for a plurality of projects including the first and second projects. According to one embodiment, the adapter component is further configured to store, in the dataset, a reference to software code that, when executed, performs the first adaptive function; and trigger execution of the software code to cause performance the first adaptive function.

According to one embodiment, the adapter component comprises a module of an application configured to interact with one or more other components of the application. According to one embodiment, interacting with the first application to perform the service comprises accessing a database of the first client computer system via an API specific to the first application.

According to one aspect, a method, performed by at least one computer, is provided. The method comprises: storing, in a dataset, a mapping of a service to a plurality of adaptive functions, each of the plurality of adaptive functions configured to interact with at least one disparate application; performing a service for a first project associated with a first client computer system using a first application, the performing comprising: determining, based on an identity of the first project, to execute a first one of the plurality of adaptive functions configured to interact with the first application; triggering execution of the determined first adaptive function; and in response to triggering execution of the first adaptive function, causing interaction with the first application to perform the service.

According to one embodiment, the method further comprises performing the service for a second project associated with a second client computer system using a second application, the performing comprising: determining, based on an identity of the second project, to execute a second one of the plurality of adaptive functions configured to interact with the second application; causing execution of the determined second adaptive function; and in response to causing the execution of the second adaptive function, causing interaction with the second application to perform the service.

According to one embodiment, the method further comprises performing the service for a second project associated with a second client computer system using the first application, the performing comprising: determining, based on an identity of the second project, to execute the first adaptive function configured to interact with the first application; causing execution of the first adaptive function; and in response to causing execution of the first adaptive function, causing interaction with the first application to perform the service.

According to one embodiment, the method further comprises storing, in the dataset, a mapping of an identifier of the first project to an identifier of the first adaptive function configured to interact with the first application to perform the service. According to one embodiment, the method further comprises storing, in the data set, a JSON configuration file specifying project specific configuration data associated with the first project for interacting with the first client computer system to perform the service. According to one embodiment, the method further comprises determining to execute the first one of the plurality of adaptive function in response to identifying the mapping of the identifier of the first project to the identifier of the first adaptive function.

According to one aspect, at least one non-transitory computer-readable storage medium storing processor-executable instructions is provided. The processor-executable instructions, when executed by at least one computer, cause the at least one computer to perform: storing, in a dataset, a mapping of a service to a plurality of adaptive functions, each of the plurality of adaptive functions configured to interact with at least one disparate application;

performing a service for a first project associated with a first client computer system using a first application, the performing comprising: determining, based on an identity of the first project, to execute a first one of the plurality of adaptive functions configured to interact with the first application; triggering execution of the determined first adaptive function; and in response to triggering execution of the first adaptive function, causing interaction with the first application to perform the service.

According to one embodiment, the processor-executable instructions further cause the at least one computer to perform: performing the service for a second project associated with a second client computer system using a second application, the performing comprising: determining, based on an identity of the second project, to execute a second one of the plurality of adaptive functions configured to interact with the second application; causing execution of the determined second adaptive function; and in response to causing the execution of the second adaptive function, causing interaction with the second application to perform the service.

According to one embodiment, the processor-executable instructions further cause the at least one computer to perform: performing the service for a second project associated with a second client computer system using the first application, the performing comprising: determining, based on an identity of the second project, to execute the first adaptive function configured to interact with the first application; triggering execution of the determining first adaptive function; and in response to triggering execution of the first adaptive function, causing interaction with the first application to perform the service.

BRIEF DESCRIPTION OF DRAWINGS

Various aspects and embodiments will be described with reference to the following figures. It should be appreciated that the figures are not necessarily drawn to scale.

FIG. 1 shows an illustrative environment in which aspect of the technology described herein may be implemented.

FIG. 2 shows an illustrative implementation of aspects of the technology described herein in an example system.

FIG. 3 shows a diagram of an illustrative data structure, in accordance with some embodiments of the technology described herein.

FIG. 4 is a flowchart of an illustrative process of performing a service, in accordance with some embodiments of the technology described herein.

FIG. 5 is a flowchart of an illustrative process of adapting a service for one or more projects, in accordance with some embodiments of the technology described herein.

FIG. 6 is a flowchart of an illustrative process of triggering an adaptive function for a project, in accordance with some embodiments of the technology described herein.

FIG. 7 is a schematic diagram of an exemplary computer system that may be specially configured to perform processes and functions disclosed herein.

DETAILED DESCRIPTION

Described herein are embodiments of systems and techniques that allow for a computer system to interact with other computer systems that employ disparate applications. According to some embodiments, the systems and techniques adapt services such that they can be performed with disparate applications. A service may comprise may comprise a functional component of an application that performs one or more tasks for the application. According to some embodiments, a service may comprise a microservice of an application. The computer system may store a dataset (e.g., a registry) in which the computer system stores association of services with adaptive functions that enable the services to be performed for various different applications used by different client computer systems. For example, the system may store a mapping of a project status update service with a plurality of adaptive functions. Each adaptive function may enable updating a project status in a client computer system for a different application. The system may further perform services for a first project associated with a first client. For example, the system may update data in a computer system of the first client indicating a status of the project for that client. The first client's computer system may employ a first application. In order to perform the service for the first client, the system may first determine, based on a project identity, to execute a particular adaptive function that is configured to interact with the first application that the first client computer system is using. The system may trigger execution of the determined adaptive function and, in response, interact with the application used by the first client computer system to perform the service (e.g., update a progress, query data, upload data to client computer system).

According to some embodiments, the system may further perform the same service for a second project associated with a second client. For example, the system may update data indicating progress of a project being worked on for the other client. A computer system of the second client may use a different application from the first client computer system or utilize the same application as the first client computer system. The system may determine, based on an identity of the second project, to execute a specific adaptive function to perform the service. In the case in which the second client computer system employs the same application as the first client computer system, the system may determine to use the same adaptive function as was used for the first project to perform the service. In the case in which the second client computer system employs a different application from the first client computer system, the system may determine to execute a different adaptive function. Upon determining which adaptive function to utilize, the system may trigger execution of the determined adaptive function and, in response, interact with the second client computer system to perform the service (e.g., update a progress, query data, upload data to client computer system). The inventors have recognized and appreciated that a computer system (e.g., a service provider's computer system) may be required to interact with several different client computer systems as part of providing service for various clients. For example, a company that provides construction, maintenance, and/or other services to different clients may have to interact with the computer systems of each of those clients. The client computer systems may use disparate applications for various tasks such as resource planning, task scheduling, contract management, asset management, raw materials management, time capture, work scoping, crew management, quality assurance, and other tasks. In one example, a first client may use an SAP enterprise resource planning (ERP) application developed by SAP SE of Germany for progress monitoring while a second client may use the P6 ERP application developed by Oracle Corporation of Redwood Shores, CA for progress monitoring. In this case, the service provider's computer system would need to be configured to interact with the SAP application and P6 application for all functionality associated with progress monitoring. In a further example, the first client may use P6 for work completion status monitoring while the second client may use SAP for work completion status monitoring. In this example, each of the first and second clients use both SAP and P6. However, each of the client computer systems employs each application for a different task.

Conventional systems may be limited in their ability interact with multiple client computer systems. A service provider may have to develop and maintain separate

applications to interact with different applications for each project. Such a system requires performing of services at a per project level. For example, if data is to be aggregated for different projects, each of which is associated with a separate client system that employs a different application, each application must be manually executed to perform the service for the different projects. Furthermore, such systems are limited or unable to perform services that require aggregation of data from many different computer systems. For example, if the service provider is to aggregate work progress statuses for multiple projects associated with multiple clients employing different applications, a conventional system would be unable to collect data from the multiple clients. Data would have to be collected for each project separately, and then aggregated thereafter.

The inventors have recognized and appreciated advantages of a system that allows a computer system to concurrently interact with multiple client computer systems, despite the disparity of applications that they employ. This may enable a service provider computer system to more efficiently execute tasks that include interacting with multiple client computer systems. For example, if the service provider computer system is to aggregate data for multiple projects associated with multiple client computer systems for tracking of progress, the service provider computer system can concurrently query data from the plurality of different client computer systems without having to execute separate applications for each of the client systems. This may allow the service provider computer system to execute data aggregation operations more efficiently, and further reduce the number of applications that must be developed, stored, and maintained in the service provider's computer system.

Furthermore, conventional systems may have specific software functionality developed for each particular client computer system. When the service provider takes on a new client, additional functionality is developed for the new client system. This may result in redundant software applications that must be stored, updated, and maintained in a service provider's computer system.

The inventors have recognized and appreciated the advantages of a system that enables a service provider' s computer system to interact with disparate applications of client computer systems without requiring additional development, maintenance, and storage of additional applications. For example, such a system may provide a service provider computer system that is more flexible, reduces storage space for application(s), and reduces maintenance activities associated with the application(s). Further, the inventors have recognized and appreciated the advantages of a system that does not require a separate application for interacting with each disparate application. For example, such a system may allow for a single application that can perform services for all of the disparate applications used by various client computer systems.

Accordingly, described herein are various embodiments of an adaptation system and techniques that enable a computer system to concurrently interact with client computer systems that use disparate applications. For example, according to some embodiments, a service provider computer system that is to interact with a first client computer system employing SAP and a second client computer system employing P6 may be able to concurrently interact with both client computer systems to perform a service (e.g., a data aggregation operation). Furthermore, various embodiments described herein provide a modular system that allows an application(s) to perform services across multiple client computer systems employ different applications. For example, functionality that enables services to be performed for separate client applications (e.g., SAP and/or P6) can be developed, stored, and maintained separate from an application that carries out core operations for performance of a service. This may provide a system that is more light weight and more efficiently carries out core tasks. Described below are various embodiments of systems and techniques that may be used for allowing a computer system to efficiently interact with multiple other computer systems employing disparate software applications. It should be appreciated that while specific embodiments are described, those embodiments are illustrative to aid in

understanding the principles described herein, and that other embodiments are possible. Embodiments are not limited to operation in accordance with any of the example set out below.

Further, although systems and techniques of embodiments are discussed herein with reference to a service provider computer system, the systems and techniques may be adapted for other types of systems, as embodiments are not limited in this respect. For example, the systems and techniques can be adapted for a materials distribution application in which a computer system must interact with computer systems of several different suppliers and customers to perform various services. Accordingly, the systems and techniques are not limited to any particular application or environment discussed herein. Additionally, although embodiments may be discussed herein with reference to specific example applications (e.g., SAP, P6, Maximo, Oracle), embodiments are not limited to any specific example

application(s). Embodiments may be configured to interact with different applications.

Additionally, embodiments described herein may be configured for different types of applications such as enterprise resource planning (ERP) applications, human resources management (HRM) applications, partner relation management (PRM) applications, planning applications, scheduling applications, and/or other types of applications. Embodiments are not limited to any particular type of application.

FIG. 1 illustrates an illustrative environment 100 in which aspects of the technology described herein may be implemented. The illustrative environment 100 includes an adaptation system 110, a service application system 120 coupled to the adaptation system 110, and user device(s) 150 in communication with the service application system 120 via network 140. The environment 100 further includes client computer systems 130, 132, 134 in communication with the adaptation system 110 via network 142. The adaptation system 110 includes a data store 112, adapter component 114, an application interface component 116, and a client interface component 118. Although the adaptation system 110 and the service application system 120 are shown as separate systems in illustrative environment 100, the service application system 120 and the adaptation system 110 may comprise components of a single system as embodiments are not limited in this respect. The networks 140, 142 may be the Internet, a local area network, a wide area network, and/or any other suitable type of communications network, as aspects of the technology described herein are not limited in this respect.

In some embodiments, a user may use a client device 150 to engage in one or more digital interactions with the service application system 120. In some instances, the digital interaction with the service application system 120, may require a performance of a service by the service application system 120. The service may involve interacting with one or more of the client computer systems 130, 132, 134. The interacting may involve retrieving and/or transmitting data to/from the client computer systems. For example, in a construction project environment, the user may request to update a status of a construction project that is being worked on for client A associated with client A computer system 130. As another example in the construction project environment, the user may request to view a record of materials required for the construction project from client A associated with client computer system 130. As another example, the user may submit a request to update project statuses for clients A-C associated respectively with client computer systems 130, 132, 134 and/or request to generate a report of progress for all projects being worked on for clients A-C. Generating the report of progress for all projects being worked on for the multiple clients may require accessing information from each of client computer systems 130, 132, 134. It should be appreciated that a user or software application on a device(s) 150 may submit any other suitable type of request to the service application system 120 in addition to, or instead of, those mentioned above, as aspects of the technology described herein are not limited to any example service discussed herein.

It should also be appreciated that the device(s) 150 may engage in other types of digital interactions in addition to, or instead of, those mentioned above, as aspects of the technology described herein are not limited to the analysis of any particular type of digital interactions. Also, digital interactions are not limited to interactions that are conducted via an Internet connection. For example, a digital interaction may involve a device 150 that is directly wired to a computer system hosting the service application system 120.

In some embodiments, during the digital interaction between device(s) 150 and the service application system 120, the service application system 120 may need to access information from one or more of client computer systems 130, 132, 134 and/or transmit information to one or more of client computer systems 130, 132, 134 to perform a service. Such services may include tasks such as updating project progress or status in a client computer system(s), sending or receiving budget information for a project, transmitting a record of time spend for a project to a client computer system(s), transmitting an indication that materials for a project have been received to the client computer system(s). In some instances, each of client computer systems 130, 132, 134 may employ different applications for different tasks. For example, the client A computer system 130 and the client B computer system 132 may utilize SAP for project progress tracking while the client C computer system 134 may utilize P6 for project progress tracking. In this example, for another type of task such as tracking status of material delivery for projects, the client A and the client B computer systems 130, 132 may employ Maximo while the client C computer system 134 may employ SAP for this purpose. Thus, when performing an update of project progress for clients A-C in the respective client computer systems, the service application system 120 may need to be able to interact with multiple different applications used by the client computer systems for different projects. In the example instance described above, the service application system 120 may need to update project progress in SAP for clients A and B while also updating project progress in P6 for client C. Furthermore, the service application system 120 may need to update material delivery information in Maximo for clients A and B while updating material deliver information in SAP for client C.

As discussed herein, in some embodiments, it may be desirable for the service application system 120 to be able to concurrently interact with different applications utilized by the different client computer systems 130, 132, 134. Furthermore, it may be desirable for a service provider to not have to develop, maintain, and store separate service applications for each of the separate client computer systems 130, 132, 134 and/or disparate applications being employed by the client computer systems 130, 132, 134. Additionally, it may be desirable for the service application system 120 to perform services that require interacting with the client computer systems 130, 132, 134 concurrently and/or in an automated sequence without requiring manual intervention.

Accordingly, in some embodiments, the adaptation system 110 enables the service application system 110 to interact with the different client computer systems 130, 132, 134 that use disparate applications for different tasks. The adaptation system 110 may include an adapter component 114 that is configured to adapt performance of a service(s) for each client computer system 130, 132, 134 and/or disparate applications used by the client computer systems 130, 132, 134. In some embodiments, the adapter component 114 may adapt a service for a respective application when it is to be performed by the service application system 120. In some embodiments, the adapter component 114 may adapt the service at runtime to enable the service to be performed for a particular application(s). For example, when the service application system 120 proceeds to update project progress for a project being worked on for client A, the adapter component 114 may adapt the service such that it can be performed specifically for an application (e.g., SAP, P6, Maximo) used by the client A computer system 130.

In some embodiments, the adapter component 114 may use adaptive functions to adapt a service (e.g., updating project progress, gather material data) for a particular application used by a client computer system. According to some embodiments, an adaptive function may comprise a function(s) that implements tasks associated with performance of a service such that the service can be performed for a particular project, client, and/or application. An adaptive function may refer to one or more functional components that adapt a service such that the service can be performed for a particular project, client, and/or application. In some embodiments, the adapter component 114 may determine a specific adaptive function to use in order to enable performance of a service for a particular project. For example, the adapter component 114 may determine that for a given project A being performed for client A, a service (e.g., updating a progress of project A in the client A computer system 130) is to be adapted for a specific application (e.g., SAP) used by the client A computer system 130. The adapter component 114 may identify an adaptive function(s) specifically designated for the project A, and trigger execution of the adaptive function(s) as part of performing the service. For example, the function may be configured to interact with the application (e.g., SAP) used by client A to update a progress of project A in the client A computer system 130.

In some embodiments, the adapter component 114 may store information specifying how a service can be adapted for a particular service in the data store 112. In some embodiments, the data store 112 may comprise a dataset that organizes a collection of data with a certain schema, such as a relational database, XML file, or other type of storage. In other embodiments, the data store 112 may comprise a non-relational database or otherwise be a data store without a set or defined schema. The data store 112 may further comprise one or more distributed data sets that are stored in distributed locations. The data store 112 may be accessed by an interface (e.g., API) by the adapter component 114.

In some embodiments, the adapter component 114 may store, in the data store 112, a mapping of a service to one or more adaptive functions. Each of the one or more adaptive functions may be configured to interact with a different application and facilitate performance of the service for the respective application. In some embodiments, the adapter component 114 may additionally or alternatively store a mapping of a project to adaptive function(s) that may be utilized to complete service(s) for the project. For example, the adapter component 114 may store a mapping of project A, being worked on for client A, to an adaptive function for completing a project progress update service for project A in the client A computer system 130. An example data schema system in accordance with embodiments discussed herein is described below with reference to FIG. 3.

In some embodiments, the adapter component 114 may be configured to adapt a service for a particular application used by a client computer system at run time. When the service application system 120 initiates performance of a particular service for one or more projects, the adapter component 114 may determine specific adaptations necessary for performance of the service. In some embodiments, the adapter component 114 determines specific adaptive functions that would enable performance of the service for the one or more projects. The adapter component 114 may trigger performance of the identified adaptive functions at run time to allow for performance of the service for a particular application used by a client computer system.

In one example, the service application system 120 may begin performance of a service that involves gathering data indicating a material delivery status for projects A and C associated respectively with clients A and C. In this example, the client A computer system 130 may use SAP for storing data indicating material delivery status while the client C computer system 134 may use Maximo for storing data indicating material delivery status. The adapter component 114 may identify, based on mapping information stored in data store 112, to trigger execution of a first adaptive function for project A associated with client A, and to trigger execution of a second adaptive function for project C associated with client C. The adapter component 114 may further trigger execution of the identified adaptive functions. In another example, both of the client A computer system 130 and the client C computer system 134 may use SAP for storing data indicating material delivery status. In this example, the adapter component 114 may identify a single adaptive function that may be executed to gather the data indicating material delivery status for both projects A and C, and trigger execution of the adaptive function for both projects A and C.

In some embodiments, the adapter component 114 may store a reference in the data store 112 via which the adapter component 114 can trigger execution of an adaptive function. The adapter component 114 may store, as part of a mapping that associates a particular project and/or service with a particular adaptive function, a reference that the adapter component 114 can use to trigger execution of the adaptive function. In some embodiments, the reference may comprise a location of software code that, when executed, executes a respective adaptive function. For example, the reference may comprise a uniform resource locator (URL) or a location of a file where the software code may be found. The adapter component 114 may then access the software code by triggering execution of software code at a URL or in a file at a given location. For example, the adapter component 114 can initiate a terminal session on a computer and initiate execution of a file. In another example, the adapter component 114 may download a file from a URL and initiate execution of the file.

Additionally or alternatively, in some embodiments, the adapter component 114 may store software code implementing various adaptive functions in the data store 112. In these embodiments, the adapter component 114 may identify an association of a project and/or service to an adaptive function, and trigger execution of the adaptive function without accessing a referenced file or location. In some embodiments, the adapter component 114 may store software code implementing the various adaptive functions in the data store 112. The adapter component 114 may, for example, store the software code in files in the data store 112. The adapter component 114 may trigger execution of software code in a file to trigger execution of a respective adaptive function.

In some embodiments, the adapter component 114 may further store configuration information that may be employed by adaptive functions. In some embodiments, the configuration information may enable an adaptive function to be used for multiple different client computer systems that use the same application. In some embodiments, the

configuration information may include address information for connecting to a client computer system, and/or login credentials for interacting with the client computer system. In some embodiments, the adapter component 114 may store configuration for each project. The adapter component 114 may store specific configuration information that may be used to perform a service for each project. For example, the adapter component 114 may store, in data store 112, a configuration file designated for each service associated with each project. In some embodiments, the configuration file may comprise a JSON file. In other

embodiments, other suitable formats may be used such as XML, HTML, or any other suitable format as embodiments are not limited in this respect.

In some embodiments, the adaptation system 110 may further include an application interface component 116. The application interface component 116 may be configured to interact with the service application system 120. In some embodiments, the application interface component 116 may be configured to receive requests from the service application system 120 to perform a service and/or to adapt a particular service for a project and/or client. In some embodiments, the application interface component 116 may receive a message from the service application system 120 indicating that performance of a service has been initiated and adaptation of the service for a project is required. In some embodiments, the application interface component 116 may include an application program interface (API) via which the service application system 120 may communicate with the adaptation system 110.

In some embodiments, the adaptation system 110 may further include a client interface component 118 that enables the adaptation system 110 to interact with the client computer systems 130, 132, 134. The client interface component 118 may be configured to communicate with respective APIs of applications employed by the client computer systems 130, 132, 134. In some embodiments, the client interface component 118 functionality may be built into the adaptive functions associated with various projects. For example, an adaptive function for adapting a service for project A associated with client A may be configured to interact via an API of an application used by the client A computer system 130 (e.g., an API for an SAP database). In some embodiments, the client interface component 118 may interact with respective adaptive functions in order to communicate with separate applications. For example, the client interface component 118 may maintain a communication interface with each application. In this example, an adaptive function may interact with a respective application via the communication interface for the application.

FIG. 2 illustrates an implementation of the adaptation system 110 in an example system 200. The system 200 includes a service provider computer system 202 (e.g., a computer system associated with a project site) that is to interact with one or more computer systems 204 (e.g., corporate back-office computer systems) via a network 254. The service provider computer system 202 includes different types of users 210 who interact with an application server 220 via a network 250 (e.g., using various client devices such as computers, laptops, smartphones, etc.). The service provide computer system 202 may further include an integration server 230 that interacts with the application server 220 via a network 252. The computer systems 204 may include computer systems associated with different parties and which employ different applications. For example, a first computer system 240 may employ P6, a second computer system 242 may employ Oracle, and a third computer system 244 may employ SAP. Each of the networks 250, 252, 254 may be the Internet, a local area network, a wide area network, and/or any other suitable type of communications network, as aspects of the technology described herein are not limited in this respect.

In some embodiments, the users 210 may comprise a plurality of different types of users that can communicate with the application server 220. For example, the users may comprise one or more people associated with a particular construction project being executed at a site. The users may include client representatives, field personnel, maintenance supervisors, maintenance superintendents, and other types of users. Each of the users may interact with an application 222 running on the application server 220. In some embodiments, a user may interact with the application 222 via a user interface provided by the application 222. For example, a user may interact with the application 222 via a device (e.g., a computer, laptop, smartphone). In some embodiments, the user can run an instance of the application 222 on the device. In other embodiments, the user may interact with the application 222 via another local application on the device (e.g., an Internet browser application).

In some embodiments, a user may interact with the application 222 and, as a result of an interaction, require the application 222 to execute one or more services. For example, a maintenance supervisor user may request a progress update for a project and/or update a progress of a project. In another example, a maintenance superintendent may request, via the application 222, to query project progresses for multiple different projects that the

maintenance superintendent is overseeing at a given time. In yet another example, field personnel may enter time worked and/or submit quality assurance data (e.g., images, videos) for a project to the application 222. A user representing a client may then request to access time entry data for the project and/or quality assurance data for the project.

In some embodiments, the application 222 may perform a variety of tasks for a service provider. For example, the application 222 may include components for managing rosters, quality assurance, human resources, task allocation, time capture, resource estimation, work pack generation, project scoping, and/or capturing lessons learned. The application 222 may include various engines that are used for executing functions associated with the various tasks. The engines may include, for example, user access control, a machine learning engine, a workforce engine, and/or a custom data source.

According to some embodiments, the application server 220 may include an adaptation module 224 that implements components and functionality of adaptation system 110 described above in reference to FIG. 1. In some embodiments, the adaptation module 224 may be implemented as part of the application 222. In other embodiments, the adaptation module 224 may be implemented as a separate application that interacts with the application 222. According to some embodiments, the application 222 manages performance of various services. For example, the application 222 may perform a service(s) in response to user interactions (e.g., requesting project progress status, updating a progress status, indicating materials for a project received). Performance of the service may require the application 222 to interact with one or more other computer systems that employ different applications. For example, the application 222 may interact with (1) computer system 240 employ P6, and a custom data source, (2) the computer system 242 employing Oracle PRM, Oracle HRM, and Oracle Core, and (3) the computer system 244 employing SAP.

According to some embodiments, the adaptation module 224 may adapt one or more services to be performed by the application 222 for different ones of the various applications used by the computer systems 240, 242, 244. The adaptation module 224 may include one or more adapters for each of the various applications used by the computer systems 240, 242, 244. For example, the adaptation module 224 may include an adapter(s) for each of P6, Oracle PRM, Oracle HRM, Oracle Core, a custom data source, and SAP. When the application 222 is to perform a service in association with one of these applications, the adaptation module 224 may adapt the service for a respective application. The adaptation module 224 may adapt a service as would adaptation system 110 described above with respect to FIG. 1. For example, for performance of a service for a project, the adaptation module 224 may determine, based on a mapping of the project to a particular adaptive function, to execute the adaptive function. The adaptation module 224 may then trigger execution of the function (e.g., by triggering execution of software code in a stored reference to a file). The adaptive function, when executed, may carry out tasks associated with the service in a manner that allows the service to be performed for a particular application. For example, the adaptive function may include software code that utilizes a specific API associated with the application that the service is being adapted for.

In some embodiments, the service provider computer system 202 may further include an integration server 230 that interacts with the application server 220 via the network 252. According to some embodiments, the integration server 230 may provide local data storage and functionality to the application server 220 such that the application server 220 does not have to communicate over an external network (e.g., the Internet) with the other computer systems 240, 242, 244. In some embodiments, the integration server 230 may store replica instances of data stores associated with specific applications of respective computer systems 240, 242, 244. For example, the integration server 230 may store (1) a replica P6 data store and custom data source data store for computer system 240, (2) replica Oracle Core, Oracle PRM, and Oracle HRM data stores for computer system 242, (3) and a replica SAP data store for computer system 244. In some embodiments, the integration server 230 may synchronize its instances of the data stores with those of computer systems 240, 242, 244. The integration server 230 may communicate with the computer systems 240, 242, 244 via network 254 (e.g., the Internet) to synchronize the instances of the data stores. For example, the integration server 230 may synchronize the local data stores every day, week, or other time interval. In another example, the integration server 230 may synchronize the data stores response to a number of updates made to the data store. In yet another example, the integration server 230 may synchronize the data stores in response to a user command.

In some embodiments, the application server 220 may interact with instances of the application data stores stored on the integration server 230. The network 252 may comprise a local network and the application server 220 may interact via the local network with the data stores in the integration server 230. In some embodiments, the adaptation module 224 may interact with the local instances via APIs specific to the application that the instance of the data store is associated with. For example, when the adaptation module 224 is adapting a service for a project for a client associated with computer system 244 which employs SAP, the adaptation module 224 may use an SAP specific API to interact with the instance of the data store on integration server 230.

Although exemplary system 200 illustrates the adaptation module 224 interacting with an integration server 230, embodiments are not limited in this respect. In some embodiments, the adaptation module 224 may interact directly with computer systems 240, 242, 244 via network 254 without using an integration server. In these embodiments, the adaptation module 224 can communicate over the network 254 directly with applications of the computer systems 240, 242, 244 without using intermediary instances of data stores on those systems.

FIG. 3 illustrates an illustrative data structure diagram 300 which may be used to implement various functionalities described herein. Data structure diagram 300 may be implemented, for example, by adaptation system 110 described above in reference to FIG. 1. For example, the adapter component 114 may store mapping information in data store 112 according to the data structure diagram 300.

In some embodiments, the adaptation system may be configured to adapt many different services (e.g., microservices for application service system 120). The system may store a service identifier 312 for each service. For example, the system may store an identifier 312 for services such as updating project progress, updating materials received status, retrieving project progress information. In some embodiments, the system may generate and/or assign an identifier for each service adapted by the system.

In some embodiments, a service may be mapped to one or more service

implementations 320. According to some embodiments, a service implementation may comprise an adaptive function that implements the service for a particular application. The system may store an identifier 322 for each of the adaptive functions that implement the services 310. In some embodiments, the system may map a service implementation 320 to the service it implements 310 by storing a reference to the service 310. For example, the system may store a service identifier 324 with a service implementation 320. In some embodiments, for a respective service implementation 320, the system may store a reference 326 to software code that executes an adaptive function to implement the service for an associated service 310. For example, the system may store a path to a binary file, a URL from which to download software code, or other location information. The system, when adapting a service, may trigger execution of the adaptive function by running the binary file, downloading and triggering execution of software code, or accessing software code from a location and executing it. In some embodiments, the system may additionally or alternatively store software code of an adaptive function directly. In these embodiments, the system may, for example, store files associated with a service implementation identifier 322 that contain software code implementing the adaptive function. The system may then trigger execution of the software code in the file to trigger execution of the adaptive function.

In some embodiments, the system may create project specific implementations 330 of a service 330 by mapping projects to specific services 310 and/or service implementations 320. In some embodiments, the system may store an project specific identifier 332 for each implementation of a service for a particular project. The system may store a project identifier 334 for a project specific implementation 330. For example, the system may store a project identifier 334 associated with a project specific identifier 332. The project identifier 334 may comprise a unique identification for a respective project. For example, for a service provider that provides construction services to various clients, the project identifier 334 may identify a specific construction project that the service provider is working on. In some embodiments, the system may map the project specific identifier 332 to a service 310 associated with the project. The system may store an association of the project specific implementation identifier 332 with an identifier of the service 336. In some embodiments, the system may further map the project specific identifier 332 to a service implementation 320 that implements the service 310 for the project. For example, the system may associate an identifier of the specific service implementation 338 with the project specific identifier 332.

In some embodiments, the system may further store configuration information 339 which includes project specific configuration data. In one embodiment, the system stores configuration data in the form of a JSON configuration file 339 for a project service implementation 330. Although the example data structure diagram 300 illustrates use of JSON configuration files, any other suitable storage format may be utilized. For example, the system may store a CSV file, an XML file, or other format of information storage. In some embodiments, the configuration file 339 may include information that may be used to interact with a particular client computer system for a particular project. For example, the

configuration file may include a physical endpoint address, special credentials required for connection to a client system, and other information required for communication with a client computer system.

According to some embodiments, by storing project specific configuration

information, an adaptive function may be used for multiple projects. For example, if multiple projects are associated with client computer systems that all use the SAP application for managing project progress for projects, a single adaptive function may be used to adapt a project progress update service for the multiple projects. The adaptive function may be configured for each specific project as required using stored configuration information specific to the project. In some embodiments, the adaptive function may be configured for a specific project at run time. For example, when a service is requested for a respective project, the adaptive function may be configured using stored configuration information. In this manner, embodiments described herein provide a system that can use a single adaptive function for multiple projects. This may reduce the amount of software code that is to be developed, maintained and stored. For example, when a client computer system information changes, the configuration information associated with projects for the client can be updated without having to modify an existing adaptive function.

In some embodiments, the system may store information about each project 340. The system may map various project details to a project identifier 342 of the project. These details may include an operator identifier of a user(s) associated with the project, a start date of the project, an end date of the project, other identifiers for the project (e.g., an identifier for an Oracle system), and/or a category of the project. In one example, a service, as part of its tasks, may update information about the project.

FIG. 4 is a flowchart of an illustrative process 400 for performing a service (e.g., in response to a user interaction or request). The process 400 may, for example, be performed by adaptation system 110 described with reference to FIG. 1.

Process 400 begins at act 402, where the system executing process 400 receives a request to perform a service for a project(s) (e.g., from a user device 150 described with reference to FIG. 1). In some embodiments, the request to perform the service may be generated by an interaction of a device with an application program (e.g., running on application program system 120). For example, the request may be generated when a user requests a particular operation or data from the application program. In some embodiments, the request may be generated by the application program in response to a particular user action. Completion of the request may require performance of a service(s) that includes interaction with one or more client computer systems. In some embodiments, interacting with a client computer system may comprise interacting via a network with the client computer system. Additionally or alternatively, interacting with a client computer system may comprise interacting with a replica of the client computer system on another computer system (e.g., a replica instance of a client computer system database on a server in a local network). A service may include an action that involves retrieving (e.g., downloading) data from the client computer system(s) and/or an action that involves transmitting (e.g., uploading) data to the client computer system(s). Examples of services include updating a progress of one or more projects, entering time information for one or more projects, updating a materials received status for one or more projects, and/or gathering data about time spent on one or more projects.

Next process 400 proceeds to act 404, where the system executing process 400 adapts a service requested to be performed for the project(s). In some embodiments, the system adapts the service requested at run time. For example, the system injects necessary dependencies (e.g., triggers execution of adaptive functions) when the request to perform the service is received (e.g., responsive to receiving the request to perform the service). In one instance, where the service is to be performed for a single project, the system may adapt the service for the single project. In some embodiments, the system may determine, based on an identity of the project, a particular adaptive function to use for adapting the service. The system may further trigger execution of the adaptive function to perform the service. In some embodiments, the system may configure the adaptive function for the project. The system may access project specific configuration data which the system uses for configuring the adaptive function. For example, the system may use project specific login credentials and/or connection addresses. The system may, for example, pass in configuration information as input arguments to the adaptive function.

In a second instance, where the service is to be performed for multiple projects, the system may adapt the service for each of the projects. Adapting the system for the multiple projects may involve adapting the service such that a function can be performed for multiple projects associated with multiple client computer systems.

In one case, the different client computer systems may use the same application for managing a task (e.g., managing project progress). The system executing process 400 may, in this case, only have to interact with one specific application to perform a given service (e.g., update project progress). In this case, according to some embodiments, the system may use the same adaptive function(s) to interact with each of the different client computer systems. The system may further configure the adaptive function such that it can be completed for each project. In some embodiments, the system may access project specific configuration information to configure the function for the project. The system may further trigger execution of the adaptive function for each project to perform the service for each project. For example, to update a project progress for a first and second project associated

respectively with a first and second client computer system, each of which employ SAP for managing project progress, the system may use a single adaptive function for both projects. In this example, the system may configure the adaptive function for each of the projects by accessing project specific configuration information.

In another case, the different client computer systems may use different applications that the system interacts with as part of performing the service. In this case, according to some embodiments, the system may use different adaptive functions to interact with the different client computer systems. The system may further configure each of the adaptive functions for an application used by a respective client computer system as described above for the single project case. The system may further trigger execution of the different adaptive functions to perform the service for each project. For example, to update a project progress for a first project associated with a first client computer system that uses SAP for managing project progress, and a second project associated with a second client computer system that uses P6 for managing project progress, the system may identify a separate adaptive function for each of the projects. The system may trigger execution of each adaptive function such that the progresses of the first project can be updated in the client computer system that uses SAP, and the progress of the second project can be updated in the client computer system that uses P6.

After adapting a service for one or more projects in act 404, process 400 proceeds to act 406 where the system executing process 400 performs the service for the one or more projects. In some embodiments, performing of the service may comprise triggering execution of an adaptive function. In response to triggering execution of a respective adaptive function, the system may retrieve and/or transmit data to a client computer system. In an instance where the system retrieves data, the system may carry out additional functions to complete performance of the service. For example, if the service involves aggregating data across multiple different projects (e.g., multiple project statuses, budget information for multiple projects), the system may perform additional processing to aggregate the data as required for the service. The system may, for example, generate aggregate data statistics, sort data across projects, and carry out other such data aggregation functions.

Next, process 400 proceeds to act 408, where the system executing process 400 outputs results of performance of the service. In one instance, outputting of results may comprise updating information in a client computer system (e.g., updating data in a client database, uploading data to a client database). In another instance, outputting of the results may comprise retrieving information from a client computer system (e.g., query for data from a client database) and outputting the retrieved information to the user. Outputting the results may include, for example, outputting retrieved data to the user (e.g., a data file(s)) and/or generating and displaying visualization(s) of retrieved data (e.g., graphs, tables).

Embodiments are not limited to any particular type output functionality.

FIG. 5 is a flowchart of an illustrative process 500 for adapting a service for one or more requested projects. The process 500 may be performed by any suitable system and/or computer device(s) such as by adaptation system 110 described above with reference to FIG. 1. Process 500 may, for example, be executed as part of process 400 described above with reference to FIG. 4.

Process 500 begins at act 502, where the system executing process 500 identifies a requested service for a project. In some embodiments, the system may receive a request to perform a service (e.g., from application service system 120 described above with reference to FIG. 1). The request may identify a service to be performed. In some embodiments, the system may store identifiers for a plurality of different services (e.g., as shown in data structure diagram 300 described above with reference to FIG. 3). An identifier may comprise a unique identification (e.g., a sequence of alphanumeric characters) for the service. A request for the service may include an identifier for a service that is to be performed. The system may identify the service to be performed based on the identifier.

Next, process 500 proceeds to act 504 where the system identifies a project for which the service is requested. In some embodiments, the system may receive the request to perform the service for multiple projects (e.g., from application service system 120 described above with reference to FIG. 1). The request may identify projects for which the services is to be performed. In some embodiments, the system may store identifiers for a plurality of different projects. A project identifier may comprise a unique identification for the project (e.g., a unique sequence of alphanumeric characters). A request to perform the service may include identifier(s) for the project(s) for which the service is to be performed. The system may identify the project(s) and select a first project for which to adapt the service.

Next, process 500 proceeds to act 506 where the system executing process 500 identifies an adaptive function implementing the service for an identified project. In some embodiments, the system may identify an adaptive function associated with the service. In some embodiments, the system may identify a requested service mapping to one or more implementations of the service (e.g., adaptive functions for that service). For example, as shown in data structure diagram 300 illustrated in FIG. 3, a service identifier may be mapped to one or more project specific implementation identifiers. The mapping may, for example, represent a single service that can be performed for multiple specific projects. In some embodiments, the system may identify a service implementation (e.g., an adaptive function) based on a project identifier. Based on the project identifier, the system may determine an adaptive function that implements the service for the project, and also configuration data specific to the project. In some embodiments, the system may store a mapping of the project identifier to an adaptive function that implements the service (e.g., project specific identifier 332 is mapped to service implementation identifier 322). The system may identify the adaptive function to execute based on the mapping of the project specific implementation to the adaptive function.

According to some embodiments, the system may store a mapping of a plurality of projects to a single service implementation. This may allow the system to use a single implementation of a service (e.g., a single adaptive function) for the plurality of projects without having to develop separate software code for each of the projects. For example, if the plurality of projects are associated with client computer systems that all use the same application associated with performance of a given service (e.g., SAP for project progress management), the system may use a single adaptive function to implement the service for each of the plurality or projects. In this manner, the system may eliminate a need to develop, maintain, and store separate applications for each of the projects.

Next, process 500 proceeds to act 508 where the system executing process 500 triggers execution of an identified adaptive function. In some embodiments, the system may store, for an adaptive function, a reference to software code for executing the service for the project. The software code, when executed, may be configured to perform a portion (e.g., all) of the requested service. For example, as shown in data structure diagram 300 in FIG. 3, the system may store a binary path reference 326. The binary path may provide a location of a binary executable file that can be triggered for execution. The file, when executed, may perform functions for performing the requested service. Although an example of a binary path reference is discussed in this example, other references may be stored and utilized to trigger execution of an adaptive function, as embodiments are not limited in this respect. Other examples include a URL from where software code can be downloaded, a file path to a file including software code, or other type of reference. Further, the system may trigger execution via the reference in any suitable manner, as embodiments are not limited in this respect. The system may, for example, initiate a terminal session and trigger execution of the adaptive function in the terminal session. In another example, the system may open an Internet browser application and trigger execution of software code in the Internet browser application.

Next, process 500 proceeds to act 510, where the system executing process 500 determines whether there are additional projects for which to perform the requested service. If the system determines that there are additional projects remaining for which the service is to be performed, the process proceeds to act 504 where the system identifies another project for which the service to be performed. The system then proceeds through acts 504 through 508 as described above. If, however, the system determines at act 510 that there are not more projects for which the requested service is to be performed, then the process 500 ends.

It should be appreciated that process 500 is illustrative and that there are variations. For example, process 500 illustrates adapting of a service for multiple projects in a sequential manner (e.g., one project at a time). In other embodiments, the system may concurrently adapt the service for multiple projects simultaneously. The process may be modified such that the service can be adapted for in parallel. The system may further trigger execution of adaptive functions for each of the multiple projects in parallel. Furthermore, although process 500 illustrates a process for adapting of multiple services, the process may be modified for adapting a service for a single project. For example, if a service is only requested for one project, then the process may adapt the service for the one project and not check for additional projects nor execute the service for multiple projects in parallel.

FIG. 6 is a flowchart of an illustrative process 600 for triggering execution of an identified adaptive function to perform a service. The process 600 may be performed, for example by any suitable system and/or computing device and, for example, may be performed by adaptation system 110 described with reference to FIG. 1. Process 600 may further be implemented, for example, for adapting a service for a project (e.g., for process 500 described above with reference to FIG. 5). Process 600 begins at act 600, where the system executing process 600 identifies an adaptive function implementing a service. According to some embodiments, the system may determine a mapping of a project to an adaptive function that implements the service for the project. In one example, the system may store a mapping as shown data structure diagram 300 shown in FIG. 3. In this example, the system may identify a mapping of a project identifier 334 to an implementation identifier 338 (e.g., an identifier for an adaptive function). Based on the mapping, the system may determine to execute the adaptive function to perform the service for the project.

Next, process 600 proceeds to act 604, where the system executing process 600 identifies a reference to software code for executing the adaptive function. According to some embodiments, the system may store a reference to the software code for the adaptive function. In one example, the system may store a reference (e.g., a file location) to the software code associated with the adaptive function (e.g., binary path 326 stored in association with adaptive function identifier 322). A reference may comprise any information specifying a location at which to access the software code or instructions according to which the software code may be accessed. Any suitable reference to the software code may be used, as embodiments are not limited in this respect. In other embodiments, the system may directly store the software code, and not a reference to the software. In such embodiments, the system may access the software code directly.

Next process 600 proceeds to act 605, where the system executing process 600 determines whether the adaptive function is in a memory of the system. In some

embodiments, the system may determine whether program instructions for executing the adaptive function are in memory. For example, if the software code for executing a respective adaptive function was previously executed, the system may have program instructions for executing the adaptive function stored in memory. In one example, an operating system of the system may have stored programming instructions corresponding to software code that implements the adaptive function in a memory of the system (e.g., random access memory (RAM) of the system). In this example, when a reference to the software code is identified to execute the adaptive function, the system may access and execute the instructions stored in the memory. In some embodiments, when the program instructions associated with the adaptive function are in memory, the system may already be configured to interact with a client computer system for a particular project. For example, to interact with an SAP application on a first client computer system for a respective project, an adaptive function may have to be configured specifically for the first client computer system, and for the SAP application. If the system had previous executed the adaptive function for the project, the adaptive function may already be configured accordingly. Accordingly, the system can trigger execution of the adaptive function from memory (e.g., by executing stored program instructions). In some embodiments, when an adaptive function is not currently in the memory of the system, the system may configure the adaptive function for the specific project.

If at act 605 the system determines that the identified adaptive function (e.g., program instructions for executing the adaptive function) is in memory, process 600 proceeds to act 608, where the system executing process 600 triggers execution of the software code. In this case, the system may proceed to act 608 without having to configure the adaptive function for the project. If at act 605 the system determines that the adaptive function is not currently in a memory of the system, process 600 proceeds to act 606, where the system executing process 600 configures the adaptive function for the specific project.

At act 606, the system executing process 600 configures the adaptive function for the project. According to some embodiments, the system may access configuration information associated with the project in order to enable performance of the service for the project. According to some embodiments, the adaptive function may use additional configuration information in order to carry out the service for the project. In some embodiments, the system may configure the adaptive function specifically for the project using the configuration information. In an example scenario in which the system executing process 600 must interact with a respective client computer system to execute the identified adaptive function, the system may require project specific configuration information. For example, the system may require information such as connection addresses, access credentials, and other information for accessing the respective client computer system. In some embodiments, configuration information may be passed as inputs to arguments of the adaptive function. In some embodiments, the system may use the configuration information to establish communication with the client computer system. For example, the system may establish a communication session using the configuration information via which the system can transmit and/or retrieve data from the client computer system.

According to some embodiments, by storing a reference to software code

implementing adaptive functions, the system allows for a modular design. Accordingly, software code for adaptive functions can be developed, maintained, and stored separately. Thus the adaptive functions can be updated and modified as needed for various projects. For example, in a case when an application with which an adaptive function(s) is configured to interact with is updated or modified, the software code implementing the adaptive function can easily be modified and/or updated accordingly. Such changes and updates may be made without modifying a service providing application (e.g., applications service system 120) itself. Furthermore, software code implementing new adaptive functions can easily be added, removed, and/or edited as required. References to software code implementing the adaptive functions can be stored by the system.

Additionally, according to some embodiments, a given adaptive function can be used for multiple projects. For example, if the multiple projects are associated with multiple client computer systems that employ the same application, the same adaptive function may be used for the clients. The system may store project specific configuration information that allows an adaptive function to be used across a plurality of projects and/or client computer systems. Accordingly, this reduces the amount of code that is to be developed, stored, and maintained by a computer system (e.g., a service provider's computer system). For example, for multiple client computer systems that all use the same application (e.g., SAP) for a particular task (e.g., project progress management), a single adaptive function may be implemented for updating project progress for each of the clients. The adaptive function may then be configured using stored configuration information to update project progress for different projects associated with different clients. In this manner, a computer system a service provider may eliminate a need for multiple separate applications and/or functions developed for separate client systems.

When the adaptive function is determined to be in memory at 605 and/or the adaptive function has been configured for the project at act 606, process 600 proceeds to act 608 where the system triggers execution of the software code. In some embodiments, when the adaptive function is in memory (e.g., program instructions for executing the adaptive function for a project are in memory), the system may trigger execution of the adaptive function from memory. For example, if an adaptive function had been previously executed for a respective project, and is to be executed again, software code for executing the adaptive function may be stored in memory. Accordingly, the system may trigger execution of the adaptive function from memory (e.g., by referencing program instructions stored in memory). In some embodiments, the system triggers execution of the software code via a stored reference to the software code. In some embodiments, the system may trigger execution of the software code via the stored reference if the adaptive function is not in memory. In one example, to trigger execution of the software code, the system may trigger execution of a binary file that includes the software code. The system may access the binary file via the stored reference. For example, the stored reference may specify a location of the binary file stored on the system or on another computer system. The system may launch an application (e.g., a terminal application) to execute the binary. In other embodiments, the system may access the software code stored at a location specified by the reference. The system may trigger execution of the software code at the location (e.g., on a computer system on which the software code is stored). In yet other embodiments, the system may cause downloading of the software code from a location specified by the reference and trigger execution of the downloaded software code.

Next, process 600 proceeds to act 610 where the system retrieves data from a client computer system and/or transmits data to the client computer system. In some embodiments, the adaptive function may be configured to utilize an API for an application running on the client computer system. For example, if the adaptive function is configured to interact with the SAP application to perform a service, the adaptive function may utilize an SAP specific API to retrieve and/or transmit the data. In one example, in which the requested service is to update a project progress for a respective project in a client computer system using SAP, the adaptive function may be configured to utilize an SAP API to perform functions specific to SAP to perform the service.

It should appreciated that process 600 is illustrative and that there are variations. For example, although the process 600 involves triggering execution of an adaptive function via a reference, in other embodiments the system may locally store the software code. In such embodiments, the system may directly execute the software code without accessing the software code via a reference. The process 600 may be modified accordingly, as

embodiments are not limited in this respect.

Various aspects and functions described herein may be implemented as specialized hardware or software components executing in one or more specialized computer systems. There are many examples of computer systems that are currently in use that could be specially programmed or specially configured. These examples include, among others, network appliances, personal computers, workstations, mainframes, networked clients, servers, media servers, application servers, database servers, and web servers. Other examples of computer systems may include mobile computing devices (e.g., smart phones, tablet computers, and personal digital assistants) and network equipment (e.g., load balancers, routers, and switches). Examples of particular models of mobile computing devices include iPhones, iPads, and iPod Touches running iOS operating systems available from Apple, Android devices like Samsung Galaxy Series, LG Nexus, and Motorola Droid X, Blackberry devices available from Blackberry Limited, and Windows Phone devices. Further, aspects may be located on a single computer system or may be distributed among a plurality of computer systems connected to one or more communications networks.

For example, various aspects, functions, and processes may be distributed among one or more computer systems configured to provide a service to one or more client computers, or to perform an overall task as part of a distributed system, such as the distributed computer system 700 shown in FIG. 7. Additionally, aspects may be performed on a client-server or multi-tier system that includes components distributed among one or more server systems that perform various functions. Consequently, embodiments are not limited to executing on any particular system or group of systems. Further, aspects, functions, and processes may be implemented in software, hardware or firmware, or any combination thereof. Thus, aspects, functions, and processes may be implemented within methods, acts, systems, system elements and components using a variety of hardware and software configurations, and examples are not limited to any particular distributed architecture, network, or

communication protocol.

Referring to FIG. 7, there is illustrated a block diagram of a distributed computer system 700, in which various aspects and functions are practiced. As shown, the distributed computer system 700 includes one or more computer systems that exchange information. More specifically, the distributed computer system 700 includes computer systems 702, 704, and 706. As shown, the computer systems 702, 704, and 706 are interconnected by, and may exchange data through, a communication network 708. The network 708 may include any communication network through which computer systems may exchange data. To exchange data using the network 708, the computer systems 702, 704, and 706 and the network 708 may use various methods, protocols and standards, including, among others, Fiber Channel, Token Ring, Ethernet, Wireless Ethernet, Bluetooth, IP, IPV6, TCP/IP, UDP, DTN, HTTP, FTP, SNMP, SMS, MMS, SS7, JSON, SOAP, CORBA, REST, and Web Services. To ensure data transfer is secure, the computer systems 702, 704, and 706 may transmit data via the network 708 using a variety of security measures including, for example, SSL or VPN technologies. While the distributed computer system 700 illustrates three networked computer systems, the distributed computer system 700 is not so limited and may include any number of computer systems and computing devices, networked using any medium and communication protocol.

As illustrated in FIG. 7, the computer system 702 includes a processor 710, a memory 712, an interconnection element 714, an interface 716 and data storage element 718. To implement at least some of the aspects, functions, and processes disclosed herein, the processor 710 performs a series of instructions that result in manipulated data. The processor 710 may be any type of processor, multiprocessor or controller. Example processors may include a commercially available processor such as an Intel Xeon, Itanium, Core, Celeron, or Pentium processor; an AMD Opteron processor; an Apple A4 or A5 processor; a Sun

UltraSPARC processor; an IBM Power5+ processor; an IBM mainframe chip; or a quantum computer. The processor 710 is connected to other system components, including one or more memory devices 712, by the interconnection element 714.

The memory 712 stores programs (e.g., sequences of instructions coded to be executable by the processor 710) and data during operation of the computer system 702. Thus, the memory 712 may be a relatively high performance, volatile, random access memory such as a dynamic random access memory ("DRAM") or static memory ("SRAM"). However, the memory 712 may include any device for storing data, such as a disk drive or other nonvolatile storage device. Various examples may organize the memory 712 into particularized and, in some cases, unique structures to perform the functions disclosed herein. These data structures may be sized and organized to store values for particular data and types of data.

Components of the computer system 702 are coupled by an interconnection element such as the interconnection element 714. The interconnection element 714 may include any communication coupling between system components such as one or more physical busses in conformance with specialized or standard computing bus technologies such as IDE, SCSI, PCI and InfiniBand. The interconnection element 714 enables communications, including instructions and data, to be exchanged between system components of the computer system 702.

The computer system 702 also includes one or more interface devices 716 such as input devices, output devices and combination input/output devices. Interface devices may receive input or provide output. More particularly, output devices may render information for external presentation. Input devices may accept information from external sources. Examples of interface devices include keyboards, mouse devices, trackballs, microphones, touch screens, printing devices, display screens, speakers, network interface cards, etc. Interface devices allow the computer system 702 to exchange information and to communicate with external entities, such as users and other systems.

The data storage element 718 includes a computer readable and writeable nonvolatile, or non-transitory, data storage medium in which instructions are stored that define a program or other object that is executed by the processor 710. The data storage element 718 also may include information that is recorded, on or in, the medium, and that is processed by the processor 710 during execution of the program. More specifically, the information may be stored in one or more data structures specifically configured to conserve storage space or increase data exchange performance. The instructions may be persistently stored as encoded signals, and the instructions may cause the processor 710 to perform any of the functions described herein. The medium may, for example, be optical disk, magnetic disk or flash memory, among others. In operation, the processor 710 or some other controller causes data to be read from the nonvolatile recording medium into another memory, such as the memory 712, that allows for faster access to the information by the processor 710 than does the storage medium included in the data storage element 718. The memory may be located in the data storage element 718 or in the memory 712, however, the processor 710 manipulates the data within the memory, and then copies the data to the storage medium associated with the data storage element 718 after processing is completed. A variety of components may manage data movement between the storage medium and other memory elements and examples are not limited to particular data management components. Further, examples are not limited to a particular memory system or data storage system.

Although the computer system 702 is shown by way of example as one type of computer system upon which various aspects and functions may be practiced, aspects and functions are not limited to being implemented on the computer system 702 as shown in FIG. 7. Various aspects and functions may be practiced on one or more computers having a different architectures or components than that shown in FIG. 7. For instance, the computer system 702 may include specially programmed, special-purpose hardware, such as an application-specific integrated circuit ("ASIC") tailored to perform a particular operation disclosed herein. While another example may perform the same function using a grid of several general-purpose computing devices running MAC OS System X with Motorola PowerPC processors and several specialized computing devices running proprietary hardware and operating systems.

The computer system 702 may be a computer system including an operating system that manages at least a portion of the hardware elements included in the computer system 702. In some examples, a processor or controller, such as the processor 710, executes an operating system. Examples of a particular operating system that may be executed include a Windows-based operating system, such as, the Windows-based operating systems, available from the Microsoft Corporation, a MAC OS System X operating system or an iOS operating system available from Apple Computer, one of many Linux-based operating system distributions, for example, the Enterprise Linux operating system available from Red Hat Inc., or a UNIX operating system available from various sources. Many other operating systems may be used, and examples are not limited to any particular operating system.

The processor 710 and operating system together define a computer platform for which application programs in high-level programming languages are written. These component applications may be executable, intermediate, bytecode or interpreted code which communicates over a communication network, for example, the Internet, using a

communication protocol, for example, TCP/IP. Similarly, aspects may be implemented using an object-oriented programming language, such as .Net, Java, C++, C# (C-Sharp), Python, or JavaScript. Other object-oriented programming languages may also be used. Alternatively, functional, scripting, or logical programming languages may be used.

Additionally, various aspects and functions may be implemented in a non- programmed environment. For example, documents created in HTML, XML or other formats, when viewed in a window of a browser program, can render aspects of a graphical- user interface or perform other functions. Further, various examples may be implemented as programmed or non-programmed elements, or any combination thereof. For example, a web page may be implemented using HTML while a data object called from within the web page may be written in C++. Thus, the examples are not limited to a specific programming language and any suitable programming language could be used. Accordingly, the functional components disclosed herein may include a wide variety of elements (e.g., specialized hardware, executable code, data structures or objects) that are configured to perform the functions described herein.

In some examples, the components disclosed herein may read parameters that affect the functions performed by the components. These parameters may be physically stored in any form of suitable memory including volatile memory (such as RAM) or nonvolatile memory (such as a magnetic hard drive). In addition, the parameters may be logically stored in a propriety data structure (such as a database or file defined by a user space application) or in a commonly shared data structure (such as an application registry that is defined by an operating system). In addition, some examples provide for both system and user interfaces that allow external entities to modify the parameters and thereby configure the behavior of the components.

Based on the foregoing disclosure, it should be apparent to one of ordinary skill in the art that the embodiments disclosed herein are not limited to a particular computer system platform, processor, operating system, network, or communication protocol. Also, it should be apparent that the embodiments disclosed herein are not limited to a specific architecture or programming language.

Various features and aspects of the present disclosure may be used alone, in any combination of two or more, or in a variety of arrangements not specifically discussed in the embodiments described in the foregoing and is therefore not limited in its application to the details and arrangement of components set forth in the foregoing description or illustrated in the drawings. For example, aspects descried in one embodiment may be combined in any manner with aspects described in other embodiments.

Also, the concepts disclosed herein may be embodied as a method, of which an example has been provided. The acts performed as part of the method may be ordered in any suitable way. Accordingly, embodiments may be constructed in which acts are performed in an order different than illustrated, which may include performing some acts simultaneously, even though shown as sequential acts in illustrative embodiments.

Use of the ordinal terms such as "first," "second," "third," etc., in the claims to modify a claim element does not by itself connote any priority, precedence, or order of one claim element over another or the temporal or der in which acts of a method are performed, but are used merely as labels to distinguish one claim element having a certain name from another element having a same name (but for use of the ordinal term) to distinguish claim elements.

Also, the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting. The use of "including," "comprising," "having," "containing," "involving," and variations thereof herein, is meant to encompass the items listed thereafter and equivalents thereof as well as additional items.

Claims

1. A system for interacting with a plurality of client computer systems using disparate applications, the system comprising:

at least one processor operatively connected to a memory; and

an adapter component, executed by the at least one processor, configured to:

store, in a dataset, a mapping of a service to a plurality of adaptive functions, each of the plurality of adaptive functions configured to interact with at least one of the disparate application;

perform the service for a first project associated with a first client computer system using a first application, the performing comprising:

determining, based on an identity of the first project, to execute a first one of the plurality of adaptive functions configured to interact with the first application;

triggering execution of the determined first adaptive function; and in response to triggering execution of the first adaptive function, causing interaction with the first client computer system to perform the service.

2. The system of claim 1, wherein the adapter component is further configured to perform the service for a second project associated with a second client computer system using a second application, the performing comprising:

determining, based on an identity of the second project, to execute a second one of the plurality of adaptive functions configured to interact with the second application;

causing execution of the determined second adaptive function; and

in response to causing the execution of the second adaptive function, interacting with the second client computer system to perform the service.

3. The system of claim 1, wherein the adapter component is further configured to perform the service for a second project associated with a second client computer system employing the first application, the performing comprising:

determining, based on an identity of the second project, to execute the first adaptive function configured to interact with the first client application;

causing execution of the first adaptive function; and in response to causing execution of the first adaptive function, interacting with the first application to perform the service.

4. The system of claim 1, wherein the adapter component is further configured to store, in the dataset, a mapping of an identifier of the first project to an identifier of the first adaptive function configured to interact with the first application to perform the service.

5. The system of claim 4, wherein the adapter component is configured to store, in the data set, a JSON configuration file specifying project specific configuration data associated with the first project to allow the adapter component to connect to the first client computer system to perform the service.

6. The system of claim 4, wherein determining to execute the first one of the plurality of adaptive functions comprises determining to execute the first adaptive function in response to identifying the mapping of the identifier of the first project to the identifier of the first adaptive function.

7. The system of claim 1, wherein the adapter component is configured to interact with a plurality of different ones of one or more of enterprise resource planning (ERP), human resources management (HRM), partner relation management (PRM), planning, or scheduling applications via the plurality of adaptive functions.

8. The system of claim 2, wherein the adapter component is further configured to perform the service for the first and second projects in response to a request to perform an aggregation operation for a plurality of projects including the first and second projects.

9. The system of claim 1, wherein the adapter component is further configured to:

store, in the dataset, a reference to software code that, when executed, performs the first adaptive function; and

trigger execution of the software code to cause performance the first adaptive function.

10. The system of claim 1, wherein the adapter component comprises a module of an application configured to interact with one or more other components of the application.

11. The system of claim 1, wherein interacting with the first application to perform the service comprises accessing a database of the first client computer system via an API specific to the first application.

12. A method, performed by at least one computer, the method comprising:

storing, in a dataset, a mapping of a service to a plurality of adaptive functions, each of the plurality of adaptive functions configured to interact with at least one disparate application;

performing a service for a first project associated with a first client computer system using a first application, the performing comprising:

determining, based on an identity of the first project, to execute a first one of the plurality of adaptive functions configured to interact with the first application; triggering execution of the determined first adaptive function; and in response to triggering execution of the first adaptive function, causing interaction with the first application to perform the service.

13. The method of claim 12, further comprising:

performing the service for a second project associated with a second client computer system using a second application, the performing comprising:

causing execution of the determined second adaptive function; and in response to causing the execution of the second adaptive function, causing interaction with the second application to perform the service.

14. The method of claim 12, further comprising:

performing the service for a second project associated with a second client computer system using the first application, the performing comprising:

determining, based on an identity of the second project, to execute the first adaptive function configured to interact with the first application;

causing execution of the first adaptive function; and in response to causing execution of the first adaptive function, causing interaction with the first application to perform the service.

15. The method of claim 12, further comprising storing, in the dataset, a mapping of an identifier of the first project to an identifier of the first adaptive function configured to interact with the first application to perform the service.

16. The method of claim 15, further comprising storing, in the data set, a JSON configuration file specifying project specific configuration data associated with the first project for interacting with the first client computer system to perform the service.

17. The method of claim 15, further comprising determining to execute the first one of the plurality of adaptive function in response to identifying the mapping of the identifier of the first project to the identifier of the first adaptive function.

18. At least one non-transitory computer-readable storage medium storing processor- executable instructions that, when executed by at least one computer, cause the at least one computer to perform:

19. The at least one non-transitory computer-readable storage medium of claim 18, wherein the processor-executable instructions further cause the at least one computer to perform:

performing the service for a second project associated with a second client computer system using a second application, the performing comprising: determining, based on an identity of the second project, to execute a second one of the plurality of adaptive functions configured to interact with the second application;

20. The at least one non-transitory computer-readable storage medium of claim 18, wherein the processor-executable instructions further cause the at least one computer to perform:

triggering execution of the determining first adaptive function; and in response to triggering execution of the first adaptive function, causing interaction with the first application to perform the service.