Node network with incremental processing

Through the Drip Feed incremental processing and pre-computing technology, the dynamic changes of large node networks and data privacy management are solved, efficient path identification and secure data sharing are realized, and computing efficiency and information protection are improved.

CN111263939BActive Publication Date: 2024-11-29ORACLE INT CORP
View PDF 3 Cites 0 Cited by

Patent Information

Application Number
CN201980005326.4
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Filing Date
2019-04-25
Publication Date
2024-11-29
Estimated Expiration
2039-04-25

AI Technical Summary

Technical Problem

Large node networks such as social networks face computing challenges and data sharing problems in dynamic changes and data privacy management, especially when node connections are frequently updated, path identification and information sharing become cumbersome and inefficient.

Method used

Using drip-feed incremental processing technology and pre-computing solutions, efficiently traverse the node network by maintaining change records in the queue and directly accessing vectors, ensuring computing efficiency and providing secure data management, and ensuring that authorized users only access their license information.

Benefits of technology

It realizes efficient identification of paths and management of node connections in dynamic networks, reduces computing complexity, improves data sharing efficiency and security, and ensures the protection of sensitive information.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN111263939B_ABST
    Figure CN111263939B_ABST
Patent Text Reader

Abstract

Embodiments include systems and methods for managing a network of nodes using incremental processing. A network having a plurality of connected nodes may be stored, the nodes representing entities of the network. One or more increments to the network may be received, the one or more increments indicating updates to connections between a plurality of nodes. The increments may be added to a queue. The increments in the queue may be used to update connections between the network nodes. After updating the connections between the nodes, the network is processed to generate a vector for a given node. One or more paths for the given node may be identified based on the generated vector.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims priority to U.S. Patent Application No. 15 / 966,439, filed on April 30, 2018, the disclosure of which is incorporated herein by reference. Technical Field

[0003] Embodiments of the present disclosure are directed to managing a network of nodes using delta processing that provides efficient graph analysis. Background Art

[0004] In recent years, social networks have demonstrated the usefulness of connections. Large networks of connected nodes can allow participating entities to identify new opportunities, whether these opportunities are new friendships, business contacts, or other useful connections. These networks also have the potential to explore synergies between groups of connected nodes. However, the benefits of connected nodes are not without risks. Large networks (such as social networks) have been plagued by issues related to data privacy, identity management, and other data sharing. In addition, due to the dynamic nature of connections, performing data analysis on connected nodes may bring unique computational challenges. Summary of the invention

[0005] Embodiments of the present disclosure are directed to systems and methods for managing a network of nodes using incremental processing that are substantial improvements over the prior art.

[0006] A network having a plurality of connected nodes may be stored, the nodes representing entities of the network. One or more increments to the network may be received, the increments indicating updates to connections between the plurality of nodes. The increments may be added to a queue. The increments in the queue may be used to update connections between the nodes of the network. The network may be processed after the connections between the nodes are updated to generate a vector for a given node. One or more paths for the given node may be identified based on the generated vector.

[0007] Features and advantages of the embodiments are set forth in the following description, or will be obvious from the description, or may be learned by practice of the present disclosure. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] Further embodiments, details, advantages and modifications will become apparent from the following detailed description of preferred embodiments taken in conjunction with the accompanying drawings.

[0009] Figure 1 A system for managing data processing of a network of nodes according to an example embodiment is illustrated.

[0010] Figure 2 Illustrated is a block diagram of a computing device operably coupled to a network data management system according to an example embodiment.

[0011] Figure 3 A functional diagram for managing data processing for a network of nodes according to an example embodiment is illustrated.

[0012] Figure 4 A diagram representing a network of nodes is illustrated according to an example embodiment.

[0013] Figure 5 A relational data table for network data processing according to an example embodiment is illustrated.

[0014] Figure 6 A flow chart of incremental processing for a network of nodes is illustrated according to an example embodiment.

[0015] Figure 7 A functional diagram for secure management of data processing for a network of nodes according to an example embodiment is illustrated.

[0016] Figure 8 An example graphical user interface for configuring a view of a network of nodes is illustrated according to an example embodiment.

[0017] Fig. 9 Illustrated is a pie chart view of network data according to an example embodiment.

[0018] Fig.10 Illustrated is a table view of network data according to an example embodiment.

[0019] Fig.11 Illustrated is a network graph view of network data according to an example embodiment.

[0020] Fig.12 A world view of a supply chain according to an example embodiment is illustrated.

[0021] Fig.13 Another world view of supply chain data is illustrated according to an example embodiment.

[0022] Fig.14 Another world view of a supply chain is illustrated according to an example embodiment.

[0023] Fig.15 An example method for managing a network of nodes utilizing incremental processing according to an example embodiment is illustrated.

[0024] Fig.16 An example method for providing secure data management for a network of nodes according to an example embodiment is illustrated. DETAILED DESCRIPTION

[0025] Embodiments manage data processing of a network of nodes. An example network may include multiple nodes with multiple connections between them. In some embodiments, the network may be a social network with various degrees of information sharing. Sometimes, a new connection may be generated between two previously unconnected nodes, or a connection between previously connected nodes may be disconnected. One or more paths may be identified based on the current configuration of the network (e.g., the current connections between the nodes). For example, a path may start from a first node and pass through a second node, a third node, and a fourth node before terminating at a fifth node. Such identified paths may be used to identify patterns, trends, or risks, perform predictions, or for other analytical purposes (i.e., depending on the nodes within the network and the particular implementation).

[0026] However, the dynamic nature of these networks presents risks and computational challenges. For example, social networks are constantly changing, building new node connections and tearing down old node connections. Therefore, identifying paths between nodes can be computationally cumbersome. As further detailed herein, embodiments utilize drip fed incremental processing to manage the network, which achieves computational efficiency while maintaining dynamic update capabilities.

[0027] Additionally, information sharing can be challenging in networks that include confidential or other sensitive information. In some embodiments, node connections (e.g., suppliers, customers, potential suppliers, potential customers, social connections, etc.) can be further defined to characterize the relationships between nodes. In these examples, the information shared by a given node in the network can be customized based on the type of connection, the distance from the given node in the network, and the custom preferences of the given node. Embodiments include security protocols to ensure that user-specific data is retrieved according to these information sharing policies.

[0028] In some embodiments, the nodes in the network can represent suppliers, intermediaries, and / or customers in the supply chain. For example, the connections between nodes can represent various relationships between these entities. A path can represent an extended relationship between multiple entities. For example, a path of multiple nodes connected by supplier / customer relationships can represent a supply chain for a commodity or product.

[0029] Based on the connections between nodes, such a network may also be referred to as a graph. Traversing this graph may be useful, for example, to identify links in a supply chain, potential links that may be used to adjust the supply chain, risks of the supply chain (e.g., geographic risk, political risk, weather risk, etc.), and for other useful purposes. However, due to the dynamic nature of some of these networks (e.g., social networks), such as frequent changes between connections between nodes, traversing a graph representing a network of nodes may present particular computational challenges.

[0030] Embodiments implement a pre-computed solution and a trickle feed increment of change records in an aggregate queue. After updating data in a network based on queued change records (e.g., drip), a graph can be processed to generate multiple direct access vectors for nodes of the graph. Embodiments include maintaining a version of pre-computed network data that can efficiently retrieve data related to graph traversal. For example, a direct access vector indication for a given node includes one or more potential paths for the given node. In some embodiments, the graph processing / pre-computed solution can include determining a transitive closure.

[0031] The precomputed solutions and / or generated direct access vectors can then be used to efficiently traverse the graph. For example, in the described supply chain embodiment, one or more paths can be identified for a given node based on the node's direct access vector, where the paths can be supply chains, potential supply chains, or some other relationship between customers and suppliers. In various embodiments, the trickle feed increments and precomputed solutions maintain graphs (e.g., social networks) that are easy to use for efficient traversal.

[0032] In some embodiments, entities (e.g., nodes) of a network may have authorized users that interact with the system. For example, an authorized user may edit an entity's profile, send messages to other entities of the network, change relationships with other entities, retrieve data related to entities of the network, perform network analysis, and other suitable functions. However, in some embodiments, confidential or sensitive information of one or more entities may be stored in association with the network (e.g., in a data repository). For example, in a social network, the system may store sensitive information of a first entity that may be shared with a subset of other entities but not with the remaining entities. In other examples, sensitive information may be marked as private and therefore may not be shared with any other entity of the social network.

[0033] In some embodiments, the system can provide secure data retrieval for entities of the network. For example, the security subsystem can maintain one or more permissions for authorized users, which determine what information the user can retrieve. Based on the security subsystem, data retrieval requests can be filtered to ensure that authorized users are only provided with information based on established permissions. For example, before performing a search on a data repository, relationship filtering can be used to filter generated queries based on permissions. In another example, data redaction can be performed on the data retrieved by the query based on the permission to redact the data before the data is provided to the authorized user. The security subsystem, relationship filtering, and data redaction can be used to ensure secure data management of sensitive or confidential data of network entities.

[0034] In an embodiment where nodes in the network represent suppliers, middlemen, and / or customers in a supply chain, secure data management can be used to provide supply chain information to network entities. For example, permissions at a security subsystem can be set based on the paths of nodes in the graph representing the network. Since the path represents the supply chain, entities on a given path can be granted permission to retrieve relevant data of the supply chain and analyze the results. An embodiment displays a graphical user interface with supply chain information based on a traversal graph and the retrieved secure data. These graphical user interfaces can be used to identify supply chain risks, analyze the efficiency of the supply chain, and for other purposes.

[0035] Currently, the retail supply chain market consists of millions of companies from fields to branches. Typically, these different companies operate different systems and practices to manage product development, procurement, compliance, orders, transportation, quality control, inventory, forecasting, replenishment, etc. Due to the complexity, adoption and capabilities of the industry's entire supply chain and this large number of desperate systems (especially for certain perishable goods, such as food or other goods that affect health), the industry often fails to achieve traceability. The scope of integration and APIs is limited, and hundreds of silos have been created. A wave of new transparent solutions and trade networks are only adding more silos as they compete with their own supply chain communities.

[0036] Embodiments provide a platform that allows various systems, micro-applications, Internet of Things ("IoT"), and smart devices (controlled by registration through the app store principle) to exchange common data sets, transaction key performance indicators (KPIs), and data links with each other. The central environment provides retailers with the ability to monitor transactions across many processes independently of the system, the ability to reuse common data sets for the supply chain, thereby improving efficiency, and data links that allow data flow across end-to-end processes. Embodiments can bring communities together, for example, through social networking capabilities. Adoption is encouraged by providing an efficient platform and services to manage multiple systems and data feeds (e.g., from one dashboard).

[0037] Such adoption can bring many benefits. Reducing duplication can significantly increase efficiency and improve data quality across the supply chain. Centralized reporting, visualization, and monitoring of transactions across the supply chain can increase efficiency, improve responsiveness, enable anticipation of risks, and provide important traceability for incidents that increase risk or cause disruptions. Data links enable various solutions to communicate on business processes, thereby improving satisfaction, user experience, and quality. Open connectivity promotes the choice of application or device, stimulates innovation, incentivizes adoption, and can be customized for a variety of capabilities around the world.

[0038] Reference will now be made in detail to embodiments of the present disclosure, examples of which are illustrated in the accompanying drawings. In the following detailed description, many specific details are set forth in order to provide a thorough understanding of the present disclosure. However, it will be apparent to one of ordinary skill in the art that the present disclosure may be practiced without these specific details. In other cases, well-known methods, processes, components, and circuits are not described in detail to avoid unnecessarily obscuring aspects of the embodiments. Whenever possible, the same reference numerals will be used for the same elements.

[0039] Figure 1 A system for managing data processing of a network of nodes according to an example embodiment is illustrated. System 100 includes a client device 102, a cloud server 104, an authentication server 106, a load balancer 108, a user interface logic 110, a stateless business service layer 112, a data access layer 114, a security policy 116, and a database 118. Client device 102 can be a computing device such as a desktop, a laptop tablet device, a cellular phone, etc. For example, client device 102 can be any computing device similar to system 210. In some embodiments, client device 102 can execute an application (e.g., a locally stored application, a web-based application, etc.) that communicates with cloud server 104 to access software services for a network of nodes.

[0040] For example, the client application may be implemented using one or more web technologies (e.g., Hypertext Markup Language (“HTML”) 5.0, JavaScript, Cascading Style Sheets (CSS), Scalable Vector Graphics (“SVG”), etc.). Such applications may be viewed using both a desktop or mobile device from a standard or mobile browser. In some embodiments, a downloadable mobile application may be developed (e.g., for iOS, Android, etc.). For example, a downloadable application may be a container application (e.g., using Cordova technology) that internally uses a “no control” browser to display a website. In various embodiments, the user's experience of the application is consistent when using a standard browser (e.g., desktop), a mobile browser, a downloadable application, or any other suitable configuration. Example communications sent to and received from client device 102 may include invitations, network messages, network-related data, and other network-related materials.

[0041] Cloud server 104 may be a server suitable for hosting a cloud-based software service platform for a network of nodes. For example, cloud server 104 may be any computing device similar to system 210 and / or may include a server embedded in Cloud(Oracle Cloud), Bare Metal, WebLogic Server and / or other suitable components (e.g., operating systems such as Linux, web technologies such as Java TM Various modules of the Engagement Engine ("EE") in Enterprise Edition ("EE"), etc.

[0042] In some embodiments, cloud server 104 communicates with authentication server 106, load balancer 108, and UI logic 110. For example, a user of one of client devices 102 may be authenticated by authentication server 106. The authenticated user may then be associated with an identity in an identity management service. An example of authentication server 106 is Identity Cloud Service (“IDCS”). Users can then access network application services based on their authenticated identities.

[0043] Load balancer 108 may be a server or module that distributes load to one or more processors (or one or more computing devices) to efficiently manage the computing resources of the system. Load balancer 108 may be any computing device similar to system 210.

[0044] UI logic 110 may be a server or module that includes software for presenting a user interface to one or more of client devices 102. For example, UI logic 110 may communicate with an application running on one of client devices 102 to present an interface for interacting with a software service for a node network. UI logic 110 may configure one of client devices 102 to display various graphical user interfaces disclosed herein.

[0045] The stateless business service layer 112 can provide stateless software services for the node network. For example, one or more microservices can be defined to securely retrieve, update, or write network data, traverse the network, send messages to participants in the network, etc. These stateless microservices are further described in this article.

[0046] Data access layer 114 may be a software layer that performs data processing functions such as query generation. For example, based on a request from stateless business service layer 112, one or more requests, commands, or updates related to stored network data may be received at data access layer 114. Queries or commands may be generated for database 118 based on the received requests (e.g., structured query language (“SQL”) queries).

[0047] Security policy layer 116 may be a software layer that protects data retrieval, update, or command of database 118 according to a stored security policy. For example, database 118 may be any suitable database for storing network data (e.g., The network data may include confidential or sensitive information of network participants. The security policy layer 116 may process updates, commands (e.g., database writes), or retrieval attempts (e.g., queries) from the data access layer 114 to filter the network data according to the stored security policies.

[0048] In some embodiments, cloud server 104, authentication server 106, load balancer 108, user interface logic 110, stateless business service layer 112, data access layer 114, security policy 116 and database 118 can be combined into a single system or computing device, can be distributed across various computing devices, and in some embodiments, can be distributed across various locations, and the combination of these can be configured in any other suitable manner. In an example embodiment, cloud server 104, authentication server 106, load balancer 108, user interface logic 110, stateless business service layer 112, data access layer 114, security policy 116 and database 118 can be software, hardware or a combination thereof.

[0049] Figure 2 2 is a block diagram of a computer server / system 210 according to an embodiment. Figure 2 As shown, the system 210 may include a bus 212 and / or (one or more) other communication mechanisms configured to transmit information between various components of the system 210, such as the processor 222 and the memory 214. In addition, the communication device 220 may implement a connection between the processor 222 and other devices by encoding data to be sent from the processor 222 to another device over a network (not shown) and decoding data received from another system over a network by the processor 222.

[0050] For example, the communication device 220 may include a network interface card configured to provide wireless network communications. Various wireless communication technologies may be used, including infrared, radio, (Bluetooth), Wi-Fi, and / or cellular communications. Alternatively, the communication device 220 may be configured to provide a wired network connection(s), such as an Ethernet connection.

[0051] The processor 222 may include one or more general or special purpose processors to perform the computation and control functions of the system 210. The processor 222 may include a single integrated circuit, such as a microprocessing device, or may include multiple integrated circuit devices and / or circuit boards that work together to perform the functions of the processor 222. In addition, the processor 222 may execute computer programs stored in the memory 214, such as the operating system 215, the network manager 216, and the additional function module 218.

[0052] The system 210 may include a memory 214 for storing information and instructions for execution by the processor 222. The memory 214 may contain various components for retrieving, presenting, modifying, and storing data. For example, the memory 214 may store software modules that provide functions when executed by the processor 222. These modules may include an operating system 215 that provides operating system functions for the system 210. These modules may include an operating system 215, a network manager 216 configured to manage data processing of the network, and additional function modules 218. The operating system 215 provides operating system functions for the system 210. The network manager 216 may include one or more APIs that enable system calls for data processing related to the network, or may also provide any other functions of the present disclosure. In some cases, the network manager 216 may be implemented as a configuration in the memory.

[0053] The non-transitory memory 214 may include various computer-readable media that may be accessed by the processor 222. For example, the memory 214 may include a combination of random access memory ("RAM"), dynamic RAM ("DRAM"), static RAM ("SRAM"), read-only memory ("ROM"), flash memory, cache memory, and / or any other type of non-transitory computer-readable media.

[0054] Processor 222 is further coupled to a display 224 , such as a liquid crystal display (“LCD”), via bus 212 . A keyboard 226 and cursor control device 228 , such as a computer mouse, are further coupled to communication device 220 to enable a user to interface with system 210 .

[0055] In some embodiments, the system 210 may be part of a larger system. Thus, the system 210 may include one or more additional functional modules 218 to include additional functionalities. The additional functional modules 218 may include, for example, embedded in The various modules of the Engagement Engine ("EE") in the cloud. Database 217 is coupled to bus 212 to provide centralized storage for modules 216 and 218, and stores, for example, wireless device activities, and in some embodiments, user profiles, transaction history, etc. Database 217 can store data in an integrated collection of logically related records or files. Database 217 can be an operational database, an analytical database, a data warehouse, a distributed database, an end-user database, an external database, a navigation database, an in-memory database, a document-oriented database, a real-time database, a relational database, an object-oriented database, an HFDS, or any other database known in the art.

[0056] Although shown as a single system, the functionality of system 210 may be implemented as a distributed system. For example, memory 214 and processor 222 may be distributed across multiple different computers that collectively represent system 210. In one embodiment, system 210 may be part of a device (e.g., a smart phone, tablet, computer, etc.).

[0057] In embodiments, system 210 may be separate from the device and may provide the described functionality to the device remotely. In addition, one or more components of system 210 may not be included. For example, for functionality as a user or consumer device, system 210 may be a smartphone or other wireless device that includes a processor, memory, and display, but does not include a processor, memory, and display. Figure 2 One or more other components shown, and including those not shown Figure 2 Other components shown in FIG.

[0058] Figure 3 A functional diagram for managing data processing of a network of nodes according to an example embodiment is illustrated. Functional diagram 300 depicts an example software framework that may provide services to users of the network. Figure 3 Included are application development framework (“ADF”) facet 302 , ADF task flows 304 , beans 306 , data models 308 , services 310 , data platforms 312 , security platforms 314 , data stores 316 , and extensible markup language (“XML”) definitions 318 .

[0059] ADF face 302 can be the view part of the software framework, including HTML, CSS and any other suitable code for providing a user interface. One of the multiple graphical user interfaces disclosed herein can be provided by ADF face 302. ADF task flow 304 can be used to configure one or more user interface elements to perform software functions. Beans 306 can provide user interface logic and integrate with the business logic rules of the model layer. ADF task flow 304 and beans 306 can be the controller part of the software framework. For example, ADF task flow 304 can be located on top of beans 306 and implement a framework for client pages. In some embodiments, ADF task flow 304 can provide a set of task flow constructs that can be used to manage the user's journey through a series of application screens. One or more functions of the elements of the graphical user interface disclosed herein can be provided by ADF task flow 304 and / or beans 306.

[0060] Data model 308 can be the model portion of a software framework. Data model 308 can provide business logic rules and structures for interfacing between user interfaces (e.g., views and controllers) and software services (e.g., the business services portion of a software framework). Service 310 can be the business services portion of a software framework. Service 310 can provide business rules, logic, validation, and structures to enable execution of software services, for example, on stored network data. Service 310 can include one or more of the microservices disclosed herein.

[0061] The data platform 312, security platform 314, and data storage device 316 can be the data service part of the software framework. The data platform 312 can map logical data to physical storage devices. For example, based on a request from the service 310, the data platform 312 can generate data commands (e.g., queries, change requests, etc.) to retrieve, store, or change data stored at the data storage device 316. These data commands are protected by the security platform 314. The security platform 314 can store security policies for filtering data commands from the data platform 312. Therefore, the data stored at the data storage device 316 is protected by the security platform 314. The data platform 312 and the security platform 314 can be defined by the XML definition 318. Therefore, these software components are agile because they can be easily updated and / or rebuilt by updating the XML definition 318. Reference Figure 7 Services 310, data platform 312, security platform 314, and data storage 316 are further described.

[0062] Return to reference Figure 1 In some embodiments, the system 100 may provide software services for a network of nodes represented by a graph. Figure 4A diagram representing a network of nodes is illustrated according to an example embodiment. Schematic diagram 400 may represent a network of nodes 402 and connections 404. Each node 402 may represent an entity participating in the graph / network, and each connection 404 may represent a relationship between the entities. In some embodiments, schematic diagram 400 is a directed acyclic graph ("DAG") or any other graph suitable for representing a network (e.g., a social network).

[0063] In some embodiments, Figure 1 The system 100 may provide software services for the network represented by the schematic diagram 400. For example, the nodes 402 may each represent an organization, and users associated with these organizations may access the network using one of the client devices 102. These users may communicate with the cloud hosting server 104 and the remaining elements of the system 100 to access, manipulate, or interact with the network of nodes. For example, the identity of the user may be authenticated by the authentication server 106 (e.g., an IDCS service or any other suitable identity management service), and the user may then interact with the network according to the permissions associated with his or her authenticated identity.

[0064] In some embodiments, each organization represented by node 402 may be registered with the network. For example, a profile may be stored for a registered organization, which may include one or more of the following: name, address or location (e.g., latitude, longitude, country of origin, and any other suitable location information), a brand associated with the organization, a home page uniform resource locator ("URL"), the organization's social media accounts, combinations of these, and other suitable information.

[0065] In an embodiment, a network of nodes may represent a network of suppliers, customers, and / or intermediaries. In such an example, an organizational profile may also include one or more of the following: products sold, products purchased, certificates from third-party associations, expired certificates from third-party associations, direct suppliers (e.g., suppliers from other entities in the network), direct customers (e.g., customers from other entities in the network), plans for goods or products (e.g., recipes), parts of goods or products (e.g., ingredients), combinations of these, and any other suitable information for buyers or sellers of products or goods.

[0066] In some embodiments, certificates from third-party associations include food or drug safety certificates (e.g., halal certificates, kosher certificates), fair trade certificates, certificates from one or more known certification entities (e.g., Global Food Safety Initiative ("GFSI"), British Retail Consortium ("BRC"), Food and Drug Administration ("FDA"), U.S. Department of Agriculture ("USDA"), Marine Stewardship Council ("MSC"), Safe Quality Food Association ("SQF"), etc.), Hazard Analysis and Critical Control Point ("HACCP") certificates, etc. These certificates typically need to be renewed, and therefore certificates may expire from time to time. Depending on the final destination of the goods or products (e.g., destination country and local regulations), expired certificates may create potential problems in the supply chain.

[0067] In some embodiments, the plan for a good or product includes a recipe or a list of ingredients used to make the good or product. For example, product A may include one or more recipes, such as recipe B, which lists ingredients C, D, E, and F. An example of a good or product may be juice. When a given organization has a recipe for a product such as juice, the organization may be considered a customer of another organization. The ingredients in the juice may be fruit concentrates (e.g., cranberries, apples, etc.), different types of fruit, and other suitable ingredients. When a given organization has ingredients for another organization's recipe, the organization may be considered a supplier.

[0068] Once registered, organizations can interact with each other in the network. For example, organizations represented by node 402 can send messages to each other, generate posts that can be shared, "like" posts from other organizations, send invitations to other organizations to join the network, and perform other functions suitable for social networks.

[0069] In some embodiments, one or more paths may be identified between nodes 402 in diagram 400 based on connections 404. For example, path 406 may include four nodes 402, such as Figure 4As shown. In an embodiment, node 402 represents an entity that may be a customer, supplier, and middleman of a transaction involving a commodity or product, and path 406 may represent a supply chain. For example, path 406 may represent a commodity or product flow between nodes 402 that terminate at an endpoint (e.g., a customer). In some embodiments, an endpoint may be one of nodes 402 representing an entity requesting information within a supply chain. For example, a node 402 representing an endpoint of path 406 may request information about a commodity or product flow to the entity representing the node. In some cases, the endpoint may be a middleman because an entity may sell a commodity or product to a downstream customer, but path 406 may represent the supply chain of the entity. An authorized user of an entity (e.g., an authenticated identity) may interact with a software service of the network to retrieve the supply chain information, as will be described in further detail below.

[0070] In some embodiments, connection 404 may represent a trading relationship between organizations (e.g., customers and suppliers). For example, organization A may invite organization B to become one of its suppliers, and / or organization B may invite organization A to become one of its customers. This may occur when organization B has an ingredient for one of organization A's recipes. Within a network, connection 404 between organization A and organization B may be established when a trading relationship invitation is sent from one organization and accepted by another organization.

[0071] In an embodiment, once two organizations have sent and accepted an invitation to enter into a trading relationship, they can identify which recipes and ingredients are dependent on the relationship. The customer organization can assign some of the ingredients used in its recipes to the new supplier organization. Similarly, the supplier organization can assign the recipes of the products it supplies to the customer organization's name. Figure 4 , when connection 404 represents a trading relationship, diagram 400 illustrates a potential flow of goods (e.g., a supply chain) between trading organizations. For example, when a supplier organization has at least one product recipe associated with a customer organization, and the customer organization has a recipe with at least one ingredient associated with the supplier organization, the supplier organization will be displayed within (considered as part of) the customer organization's supply chain.

[0072] In some embodiments, connection 404 may represent a social relationship (not a trade relationship). For example, organization A may submit a social connection request to organization B, and connection 404 representing a social connection may be formed.

[0073] In some embodiments, the network data may be mapped to a plurality of relational data tables in a relational database. Figure 5 A relational data table for network data processing according to an example embodiment is illustrated. Figure 5The example data tables illustrated in FIG. 5 include organizations 502, connections 504, recipes 506, ingredients 508, Recipe_Ingredients 510, Recipes_Consumers 512, and Ingredients_Suppliers 514. The data tables may include attributes (e.g., ID, name, etc.) and may include key information (e.g., primary and foreign keys) in some cases. For purposes of this disclosure, the illustrated data schema has been simplified, and the implementation of the data schema for network data may be much larger than the illustrated example. Other suitable schemas may also be implemented.

[0074] In some embodiments, organization 502 can store organization profile information, such as organization ID, name, other profile information detailed herein, and any other suitable organization profile information. Connection 504 can store information about connections between nodes, such as connection ID, consumption ID (e.g., customer ID), production ID (e.g., supplier ID), and any other suitable connection information. In some embodiments, connections between nodes can be based on the realization flow of goods or products (e.g., realized supplier / customer relationships).

[0075] In some embodiments, recipes 506 may store recipe information, such as a recipe ID, a recipe description, an owner organization ID, and any other suitable recipe information. Similarly, ingredients 508 may store ingredient information, such as an ingredient ID, an ingredient title, an owner organization ID, and any other suitable ingredient information. Recipe_Ingredients 510 may store associations between owned recipes and owned ingredients.

[0076] In some embodiments, Recipes_Consumers 512 may store information associating a recipe with a connection that consumes the recipe, such as a connection between organizations represented by a connection ID stored in Connections 504. Similarly, Ingredients_Suppliers 514 may store information about ingredients and connections that supply the ingredients. For example, Recipes_Consumers 512 and Ingredients_Suppliers 514 may be used to determine how organizations from a given connection are connected (e.g., the recipe / ingredient trading relationship that exists between them).

[0077] For example, a first organization owns a formula A that may include ingredients B, C, and D. A second organization owns ingredients that may include ingredients D, E, and F. Because the first organization owns a formula that includes an ingredient owned by the second organization (ingredient D), there is a potential flow of goods or products between the first organization and the second organization. In some examples, the first organization and the second organization may confirm a trading relationship so that a connection (with a connection ID) may be formed. Once connected, the first organization may associate formula A with the connection, and the second organization may associate ingredient D with the connection. Figure 5 The table shown in the figure is populated with relevant connection, ingredient, and recipe information.

[0078] Return to reference Figure 4 , mapping the node network onto the data table may include storing entity-specific (e.g., organization profile) information for the node 402 in the organization 502 and storing node connection information for the connection 404 in the connection 504. As described in detail below, processing the network to generate a vector for the node 402 may be managed based on associations between owned recipes and owned ingredients indicated by the recipes 506, ingredients 508, recipe_ingredients 510, recipes_consumers 512, and / or ingredients_suppliers 514.

[0079] In some embodiments, a user (e.g., associated with one of the nodes / entities of the network) can request updates or changes. For example, an authenticated user can request changes to the network, such as changes to a commodity or product flow (e.g., a new or updated supplier / customer relationship), a new commodity or product flow, a change to an owned formula or ingredient, a new formula or ingredient, or any other suitable change. Changes to the network can also include creating new nodes / entities based on newly registered organizations. New nodes / entities can generate connections to existing entities / nodes based on existing or new commodity or product flows.

[0080] Figure 4 The new connection 408 shown may be the result of a change to the schematic 400. For example, the node 402 connected by the new connection 408 may enter an agreement for trade in goods or services. Based on the updates to the schematic 400, new paths and new potential paths are generated. As detailed herein, processing requests to traverse a graph such as a social graph with a high frequency of change may be computationally challenging. An embodiment implements trickle feed incremental processing to provide an efficient technique for traversing the schematic 400 even in the presence of frequent changes.

[0081] Figure 6A flowchart 600 for incremental processing of a network of nodes according to an example embodiment is illustrated. An incremental 602 may be requested to update or change a network data 606 (e.g., stored in a relational data table). The incremental 602 may be stored in a queue 604, such as a first-in, first-out (FIFO) queue or any other suitable queue. Each processed change or update may be viewed as a drip in a trickle-feed incremental processing stream. When an update or change is performed on the network data 606, one or more paths or potential paths between network entities may be changed. For example, one of the incrementals 602 may result in a change that generates a new product or commodity flow (or a new potential product or commodity flow) and / or generates a connection similar to the new connection 408 (e.g., based on a change to an ingredient, recipe, or product owned). After the update to the network data 606 is completed, the next drip may be performed (e.g., the network data 606 may be updated or changed based on the incremental 602 at the top of the queue 604).

[0082] In some embodiments, network data 606 may represent a precomputed version of underlying network data (e.g., stored in a Figure 5 ). For example, network data 606 may be precomputed data useful for efficient retrieval of network information, such as paths between nodes / entities (e.g., supply chain information). Users (e.g., authenticated users with appropriate security) may easily update / change the base network data, for example, by logging into and interacting with a client application, and these updates / changes may be reflected in the base network data without the use of queues. However, increment 602 may represent updates / changes that affect network data 606 (e.g., a precomputed version of the base network data). An embodiment implements a trickle-feed increment technique when updating network data 606 to maintain this precomputed version of the base network data, which is useful for efficient retrieval of network information.

[0083] In some embodiments, network data 606 is stored in a collection of relational data tables that are separate from the base network data. Network data 606 can be considered a copy of the base network data in pre-computed form. In order to maintain this pre-computed form (and the benefits of efficient network data retrieval), updates are managed through the disclosed trickle feed incrementation technique. In other words, it is an update / change (e.g., increment 602) to a separate set of related data tables that are queued (e.g., in queue 604) and executed as trickle feed increments. Network data 606 is ultimately consistent with the base network data (after executing the trickle feed incrementation) and provides a structure that enables high-performance querying of the network.

[0084] In some embodiments, processing of deltas 602 is performed on a best-effort basis based on available computing resources. Processing delays may be due to differences between the rate at which the server (based on user activity) can generate deltas 602 and the rate at which the pre-computation engine can process / remove them from queue 604. In some embodiments, processing of deltas may be delayed and / or may be performed at predetermined intervals (e.g., delays may be built into the process).

[0085] In some embodiments, updates / changes to the underlying network data (e.g., Figure 5 The change of the relational data table of the network data 606 is determined by determining the change that affects the separate data table storing the network data 606. For example, the following scenario represents the change that affects the network data 606 (for example, the change that needs to be queued):

[0086] 1) Two organizations create a new trade relationship or terminate an existing trade relationship;

[0087] 2) The two organizations terminate their existing trade relations;

[0088] 3) Recipes or ingredients maintained by the customer or supplier are updated to associate the new organization as the customer (of the product / recipe) or supplier (of the ingredient); and

[0089] 4) Recipes or ingredients maintained by customers or suppliers are updated so that they remove the organization that is no longer a supplier of an ingredient or a customer of the product / recipe.

[0090] In some embodiments, updates / changes to the underlying network data may be tracked to identify one or more of these above scenarios. Figure 5 The relational table structure of can identify the following updates / changes as affecting network data 606.

[0091] Add / remove consumers to / from a recipe (INSERT, DELETE RECIPES_CONSUMERS 512)

[0092] Add / remove ingredients to / from a recipe (insert, delete into table RECIPE_INGREDIENTS 510)

[0093] Add / remove suppliers to / from ingredients (insert, delete into table INGREDIENTS_SUPPLIERS 514)

[0094] It should be noted that in each of these cases, the changes can be implemented by a user (e.g., an authenticated user with permission) using a client application. Embodiments of the disclosed technology generate deltas 602 corresponding to these changes, which are used to update network data 606 to maintain a pre-computed version of the base network data.

[0095] In some embodiments, a database function (e.g., RDBMS triggers) can be used to process the increments 602. Example techniques for queuing include Advanced Queuing ("AQ"). Increments 602 in queue 604 may be processed, and a data table storing network data 606 (e.g., including a transitive closure of a graph) may be incrementally updated. In some embodiments, multiple queue consumers may be implemented therein, and these consumers may be shared by various organizations. An example schema for a data table storing network data 606 may be as follows:

[0096] PC_RECIPE_CON_SUP—Stores a precomputed copy of the recipe and consuming organization relationships (recipe ID, consuming organization ID, and supplying (owning) organization ID).

[0097] PC_RECIPE_INGREDIENTS—Stores a precomputed copy of ingredient-to-recipe relationships (recipe ID and ingredient ID).

[0098] PC_INGREDIENT_CON_SUP—Stores a precomputed copy of the ingredient and supplying organization relationship (ingredient ID, consuming (owning) organization ID, and supplying organization ID).

[0099] PC_INGREDIENT_CONNECTIONS - Stores precomputed versions of the ingredients into possible ingredient connections, and thus can be used to traverse through the network. This is used to assist in incremental evaluation of transitive closure.

[0100] PC_ORG_TC_RECURSIVE—Store the pre-computed version of the organization in the organization transitive closure and use it as one of the tables that the application uses to query the network. In some embodiments, the design of the table is simple and consists of the ID (of the recursive transitive closure entry), the consumer organization ID, and the supply organization ID.

[0101] PC_ORG_TC_PATH—Stores a precomputed version of all the ways (paths) that can be obtained from a consuming organization ID to a supplying organization ID in PC_ORG_TC_RECURSIVE.

[0102] PC_ORG_TC_ING_CONN_PATH_H - This table holds the header record of a component path. This record includes the organization transitive closure path ID from PC_ORG_TC_PATH that made this component path possible. This is used to assist in incremental evaluation of transitive closure.

[0103] PC_ORG_TC_ING_CONN_PATH_D—This table holds a detailed record of the component paths from PC_ORG_TC_ING_CONN_PATH_H. This is used to assist in the incremental evaluation of transitive closure.

[0104] Embodiments include generating updates / changes (e.g., deltas 602) to a data table storing network data 606 (e.g., the above schema) corresponding to tracked changes identified as affecting the network data 606. For example, a tracked change may be identified as an update to a trading relationship between two entities / nodes. One or more deltas 602 may be generated to update a data table storing network data 606. For example, based on the implemented schema, a tracked change may correspond to multiple deltas 602 that update / change multiple tables storing network data 606.

[0105] In some embodiments, performing the trickle (eg, increment) includes determining the transitive closure of the network. Figure 4 , a transitive closure of the diagram 400 can be maintained for a given node based on a subset of nodes 402 that are part of a path or potential path with the given node. Potential connections or flows of goods or products can be identified based on ingredients, recipes, associated entities / nodes, and related information stored and updated in a data schema maintained for network data 606 (e.g., the data schema disclosed above). In general, for a given node, the transitive closure of the diagram 400 represents a subset of nodes 402 that can be included on a path (e.g., an existing path or a potential path) with the given node. The transitive closure of the diagram 400 can be determined in any suitable manner (e.g., a breadth-first or depth-first search of a graph, a Floyd-Warshall algorithm, etc.).

[0106] In determining the transitive closure, a rule or data set that enumerates paths from one node to other nodes may be used. In various embodiments, established trade relationships between nodes / entities may be used as a technique for enumerating paths. The following is an example algorithm for determining the transitive closure of the schematic diagram 400:

[0107] For node X:

[0108] For each formulation of X,

[0109] For each ingredient of the recipe

[0110] For each supplier of ingredients

[0111] Add a supplier to the potential supplier node list

[0112] For each node in the Potential Supplier Nodes list

[0113] Check to see if this node has at least one recipe tagged with node X as a client

[0114] If no, then remove the node from the Potential Supplier Nodes list

[0115] / / "Potential supplier node" is the next level node in the supply chain of node X.

[0116] The algorithm is recursively executed on each node in the list to produce the node's next level suppliers. For each new recursion, the node that is the subject of the current iteration becomes the new "X".

[0117] The results of the determined transitive closure may be stored as network data 606 (eg, in a data table similar to the example schema). Figure 6 , can be based on an operation performed by a user (e.g., stored in Figure 5 Increment 602 is generated based on one or more changes to the underlying network data (in a data table of the underlying network data) so that each data table storing network data 606 affected by the change to the underlying network data is updated. In other words, in the case of a change to the network data of a piece of information A, increment 602 can be generated to update any data table storing information A or network data 606 storing information that depends on information A.

[0118] In some embodiments, maintaining the transitive closure of schematic 400 includes modifying a precomputed version of network data (e.g., network data 606) rather than recomputing the entire transitive closure. If a full rebuild is requested (e.g., based on a database failure or some other requirement), then rebuilding of the transitive closure can be performed based on connection, recipe, and ingredient records.

[0119] In some embodiments, determination of the transitive closure of the diagram 400 provides a direct access vector for each node 402. For example, the transitive closure of the diagram 400 may provide a list of all nodes reachable from a given node:

[0120] Given a node "X", the closure of "X" is a list of objects, where each object is represented by:

[0121] 1) The ID of the node ("Y") that can be reached from "X"

[0122] 2) A set of alternative paths that describe all possible ways to get from "X" to "Y" in the graph. Each alternative path may include a list of node IDs that would be traversed from "X" to get to "Y".

[0123] The direct access vector of a given node may be selected in a relational data query to return a subset of nodes that are part of a path with the given node. In other words, a request to traverse the diagram 400 and return a path for a given node may use the direct access vector of the given node and a relational query to efficiently retrieve the requested network data from a relational data table (e.g., data schema 606 for network data). Embodiments provide computationally efficient techniques for traversing the diagram 400 to provide network software services, such as path identification and corresponding data retrieval.

[0124] In some embodiments, software services such as stateless microservices can be utilized to access, update, change, delete, or retrieve data of a network of nodes. Incremental processing of updating or changing network data allows efficient access to the data, however, some organizations may store sensitive or confidential information in the system. Therefore, security policies and security filtering of network data can be provided to further improve the management of network data.

[0125] Figure 7 A functional diagram for secure management of data processing for a network of nodes according to an example embodiment is illustrated. For example, functional diagram 700 may represent software functions for implementing secure data processing for a network of nodes disclosed herein.

[0126] Functional diagram 700 includes services 702, data platform 704, security platform 706, and data store 708. Data platform 704 may include application programming interface ("API") 710, XML definition 712, and logical to physical mapping 714. Security platform may include data collation 716, relationship filtering 718, trusted repository 720, and XML configuration 722. In some embodiments, services 702, data platform 704, security platform 706, and data store 708 may be similar to Figure 3 services 310 , data platform 312 , security platform 314 , and data storage device 316 .

[0127] In some embodiments, service 702 may include multiple microservices provided to users to interact with the node network. For example, a user (operating a client device) affiliated with a registered organization (e.g., an entity of the network) can use multiple public APIs to call various microservices to interface with the network system and access network data.

[0128] In some embodiments, service 702 communicates with data platform 704 using API 710 to access, update, change, or delete network data stored at data store 708. XML definitions may define data that may be retrieved from data store 708. Additionally, logical to physical mapping 714 may be used to map logical data requests or commands to physical level requests or commands (e.g., relational data queries).

[0129] In some embodiments, physical level requests or commands (e.g., structured query language ("SQL") commands or queries) are transmitted to security platform 706 for filtering or augmenting according to stored security protocols before executing the requests or commands against data store 708. Trusted repository 720 is an immutable source of security policy for the network that stores access permissions for registered users and organizations.

[0130] For example, access to data repository 708 may be protected according to access permissions stored at trusted repository 720. In some embodiments, trusted repository 720 may store an organization key for writing profile data for a first organization. In this example, users of the first organization would be able to write profile data to their own organization, but would be blocked from writing profile data to any other organization, even if such a write is requested by one or more services 702 or by other code of the network system.

[0131] In some embodiments, queries or commands (e.g., SQL) transmitted from the data platform 704 may be filtered or enhanced by the relationship filter 718 according to the security policy stored at the trusted repository 720. In addition, any data retrieved by the filtered or enhanced query may be collated by the data redaction 716 according to the security policy stored at the trusted repository 720. In some embodiments, the security platform 706 may be configured using an XML configuration 722, which includes a plurality of XML files that define security protocols (e.g., access permissions, query filtering, and data redaction).

[0132] Embodiments include multiple stateless microservices that can be used to interface with a network system. In one embodiment, a microservice is an independently deployable service. In one embodiment, the term "microservice" contemplates a software architecture design pattern in which complex applications are composed of small independent processes that communicate with each other using language-independent APIs. In one embodiment, microservices are small, highly decoupled services, and each microservice can focus on completing small tasks. In one embodiment, the microservice architecture style is a method of developing a single application as a set of small services, each of which runs in its own process and communicates with a lightweight mechanism (e.g., HTTP resource API). In one embodiment, microservices are more easily replaced than single-piece services that perform all or many of the same functions. In addition, each microservice can be updated without adversely affecting other microservices. In contrast, an update to a part of a single-piece service may unexpectedly or unintentionally negatively affect other parts of the single-piece service. In one embodiment, microservices can be beneficially organized around the capabilities of microservices. In one embodiment, the startup time of each microservice in a microservice set is much less than the startup time of a single application of all services that jointly execute these microservices.

[0133] In one embodiment, a microservice architecture refers to a specialization (i.e., separation of tasks within a system) and implementation approach of a service-oriented architecture ("SOA") for building flexible, independently deployable software systems. Services in a microservice architecture are processes that communicate with each other over a network to achieve a goal. In one embodiment, these services use technology-independent protocols. In one embodiment, services have a smaller granularity and use lightweight protocols. In one embodiment, services are independently deployable. By distributing the functionality of a system into different small services, the cohesion of the system can be enhanced and the coupling of the system can be reduced. This makes it easier to change the system and add functionality and quality to the system at any time. It also allows the architecture of individual services to be formed through continuous refactoring, and therefore reduces the need for large upfront design and allows software to be released early and continuously.

[0134] In one embodiment, in a microservice architecture, an application is developed as a collection of services, and each service runs a corresponding process and communicates using a lightweight protocol (e.g., a unique API for each microservice). In a microservice architecture, software can be decomposed into individual services / functions at different levels of granularity according to the services to be provided. A service can be a runtime component / process. Each microservice can be a self-contained module that can dialogue with other modules / microservices. Each microservice can have an unnamed universal port, and other ports can be contacted with it. In one embodiment, the unnamed universal port of a microservice is a standard communication channel (e.g., as a conventional hypertext transfer protocol ("HTTP") port) that is conventionally disclosed by the microservice, and any other module / microservice in the same service is allowed to dialogue with it. In one embodiment, microservices are independent of each other, atomic, and stateless. A microservice or any other self-contained functional module can generally be referred to as a "service."

[0135] For example, one of the stateless microservices can be an identity management service, such as an IDCS microservice, for authenticating a user's identity. For example, a user associated with an organization can provide their organizational credentials, and the IDCS microservice can be configured to perform authentication using the user's organization's identity management system to ensure that the relevant system correctly authenticates the user's identity. The following example represents a subset of the API of the IDCS microservice:

[0136] User(user)GetCurrentUser

[0137] Gets the current user identified by the currently logged in user.

[0138] User GetUser(String emailAddress)

[0139] Gets a user identified by an email address. It queries IDCS for the username attribute.

[0140] String CreateUser(User toCreate)

[0141] Create a new user and add it to a group. The group display name is configurable in the context parameters of the application (web.xml). Before creating a user, you can search for the IDCS group to add the user to. The search can call the API and search for a group whose display name matches the configured parameters. Once found, it can extract the group ID (not visible in the UI) and use it to create an update (PATCH) request to the IDCS server to add the newly created user. After the operation is successful, the newly created user ID (GUID) is returned.

[0142] In some embodiments, various microservices can rely on each other's APIs to perform functions. For example, the IDCS microservice can rely on functions provided by one or more other microservices in order to complete the functions described above for the example API. In addition, the IDCS microservice can request functions from the organization's identity management system in order to fully implement user authentication. For example, an organization can implement a cloud-based user authentication system, such as the system described in U.S. Patent No. 9,838,376.

[0143] In another example, one or more microservices may be used to create, read, update, or delete ("CRUD") network data from the data store 708. For example, various microservices may expose custom or CRUD interfaces that provide access to the "business functionality" represented by the microservice. In some examples, the microservices may represent business entities (e.g., company profiles, invitation lists, recipes, etc.). The CRUD verbs may allow the corresponding entity flows to be read or manipulated. As will be further detailed below, such services may also rely on the functionality of the security platform 706 to ensure compliance with the system's security policies. The following example represents a subset of the API of one or more CRUD microservices:

[0144] Void Create(T items)

[0145] Void Create(IDDRS <t>items)

[0146] IDDRS <t>Read(Map<String,Object>parameters,FilterClause filterClause,SortClause sortClause)

[0147] IDDRS <t>Read(Class <t>returnDataRecordClass,Map<String,Object>parameters,FilterClause filterClause,SortClause sortClause)

[0148] PagedData<?>ReadPage(Map<String,Object>params,,FilterClausefilterClause,SortClause sortClauseOverride,int firstRecord,int PageSize)

[0149] IDDRS <t>ReadMetaData()

[0150] Void Update(IDDRS <t>updates)

[0151] Void Delete(IDDRS <t>deletes)

[0152] Void UpdateCreate<IIDRS <t>updateCreates)

[0153] CRUD Base

[0154] GRUD Base

[0155] - An implementation of the ICRUD interface used by service implementations that wish to use standard CRUD over the underlying data repository.

[0156] -based CRUD will expect the datastore id to direct the CRUD operations.

[0157] Generic CRUD

[0158] -Generic data implementation of ICRUD interface for un-typed CRUD actions on data repositories. The service will expect a data repository id to indicate the CRUD operation.

[0159] CRUD factory

[0160] - A factory for constructing generic data implementations of the ICRUD interface

[0161] In another example, the organization microservice can be used to manage information of organizations registered with the node network. For example, as previously disclosed, each organization can have a profile with multiple attributes. The organization microservice can call one or more functions of the CRUD microservice to access, create, or update the organization information stored in the data storage device 708. For example, the organization microservice can provide the following functions:

[0162] Create

[0163] - Standard creation based on CRUD microservices

[0164] -Rely on data constraints in the data source to enforce mandatory fields

[0165] Read

[0166] -Standard read based on CRUD microservice

[0167] Update

[0168] - Standard updates based on CRUD microservices

[0169] -Rely on data constraints in the data source to enforce required fields

[0170] Update Create

[0171] - Standard update creation based on CRUD microservices

[0172] -Rely on data constraints in the data source to enforce required fields

[0173] Users can also use the organization microservice to find organization-specific information and retrieve the organization's products. The following example represents a subset of the API of the organization microservice:

[0174] Public IDynamicDataRecordSet <organisation>find(long orgId)

[0175] Public IDynamicDataRecordSet <product>getProducts(Organisation org)

[0176] In some embodiments, IDynamicDataRecordSet (IDRS) is a general data structure that allows for the representation of variable data streams. IDRS may include several parts:

[0177] 1) A list of records represented by a data stream, e.g. one record per entity.

[0178] 2) Each entity record can have a set of attribute pairs: attribute ID and attribute value.

[0179] 3) Each entity record can contain a list of entity records. Examples including such features can allow for hierarchical representations.

[0180] 4) In parallel with the above data, IDRS can contain metadata. Metadata can have an entry for each attribute available in the entity record. This metadata describes the characteristics of the data. An example is as follows:

[0181] a. Physical data type in the database, such as text

[0182] b. Business type - e.g. password

[0183] c. Range of possible values

[0184] d.Required field

[0185] e. Validation rules

[0186] f.Default value

[0187] g. Etc.

[0188] Embodiments utilizing IDRS can take advantage of the benefits of data structures, at least because the structure can represent values, records, lists, hierarchical structures, and other concepts in a standard manner. These representations can be self-describing, for example, due to the metadata included. Embodiments of network data can be represented as IDRS structures. Such embodiments allow general processing units or UI components to accept unusual data arrays, at least because the IDRS structure provides instructions on how to navigate and understand it.

[0189] In another example, a user profile microservice can be used to manage user profiles for users of a node network. For example, each user can have a profile that includes information specific to the user, such as organizational affiliations. The user profile microservice can call one or more functions of the CRUD microservice to access, create, or update user profile information stored in the data storage device 708. For example, the following represents a subset of the functions that the user profile microservice can provide:

[0190] Create

[0191] - Standard creation based on CRUD microservices

[0192] Read

[0193] -Standard read based on CRUD microservice

[0194] Update

[0195] - Standard updates based on CRUD microservices

[0196] Update Create

[0197] - Standard update creation based on CRUD microservices

[0198] In another example, the ingredient microservice may be used to interface with ingredient information stored in the data store 708. A subset of the functionality of the ingredient microservice is as follows:

[0199] definition:

[0200] Metadata Definition

[0201] ·Element

[0202] As provided by RdbmsStandardAttributes

[0203] ·Ingredients_CRUD(Components_CRUD)

[0204] As provided by RdbmsStandardAttributes

[0205] Dynamic data definition

[0206] ·Element

[0207] Read the title (Caption), ParentProductId and OwnerOrgId

[0208] Ingredients_CRUD

[0209] As provided by RdbmsStandardAttributes

[0210] Function:

[0211] The implementation of standard CRUD operations is as follows:

[0212] Read

[0213] Use the component data stream implemented as part of CrudBase.

[0214] Delete

[0215] Override with the Ingredients_CRUD data flow.

[0216] CreateItemsEx(Long ownerOrgId,Long parentProductId,IDynamicDataRecordSet items) throws ORSCN_ServiceException

[0217] Iterate through the list of items and set the OwnerOrgId and parentProductId

[0218] Invoke repository creation using the Ingredient_CRUD data flow.

[0219] UpdateCreateEx(Long ownerOrgId,Long parentProductId,IDynamicDataRecord item)throws ORSCN_ServiceException

[0220] Set OwnerOrgId and parentProductId

[0221] Call the repository updateCreate using the Ingredient_CRUD data flow.

[0222] ReadIngredient(Long ingredientId) throws ORSCN_ServiceException

[0223] Call the static readIngredient on the ingredient entity

[0224] οIf IngredientId is null, then return null

[0225] o Call the repository read using the Ingredients_CRUD data flow filtering on IngredientsId.

[0226] o If an ingredient is returned, extend the supplier information by calling read on the repository using the IngredientSuppliersCaptions data flow and replace the supplierIds attribute.

[0227] Update

[0228] Not implemented, throws an exception.

[0229] Create

[0230] Not implemented, throws an exception.

[0231] Create / Update

[0232] Not implemented, throws an exception.

[0233] In another example, a similar recipe microservice may be used to interface with recipe information stored in data storage 708. A subset of the functionality of the recipe microservice is as follows:

[0234] definition:

[0235] Metadata Definition

[0236] ·formula

[0237] As provided by RdbmsStandardAttributes

[0238] Recipes_CRUD

[0239] As provided by RdbmsStandardAttributes

[0240] Dynamic data definition

[0241] ·formula

[0242] Read the title (Caption), ParentProductId and OwnerOrgId

[0243] Recipes_CRUD

[0244] As provided by RdbmsStandardAttributes

[0245] Function:

[0246] The implementation of standard CRUD operations is as follows:

[0247] Read

[0248] Use the recipe data stream implemented as part of CrudBase.

[0249] Delete

[0250] Override with the Recipes_CRUD data flow.

[0251] CreateItemsEx(Long ownerOrgId,Long parentProductId,IDynamicDataRecordSet items) throws ORSCN_ServiceException

[0252] Iterate through the list of items and set the OwnerOrgId and parentProductId

[0253] Use the Recipes_CRUD data flow to call repository creation.

[0254] UpdateCreateEx(Long ownerOrgId,Long parentProductId,IDynamicDataRecord item) throws ORSCN_ServiceException

[0255] Set OwnerOrgId and parentProductId

[0256] Call the repository updateCreate using the Recipes_CRUD data flow.

[0257] ReadRecipe(Long recipeId) throws ORSCN_ServiceException

[0258] Call the static readRecipe on the recipe entity

[0259] οIf recipeId is null, then return null

[0260] o Call repository read using the Recipes_CRUD data flow filtering on recipeId.

[0261] o If a recipe is returned, extend the consumer information by calling read on the repository using the RecipeConsumersCaptions data stream and replace the consumerIds attribute.

[0262] o If a recipe is returned, a read is called on the repository using the RecipeIngredientsCaptions data flow to expand the ingredient information and replace the ingredientIds attribute.

[0263] Update

[0264] Not implemented, throws an exception.

[0265] Create

[0266] Not implemented, throws an exception.

[0267] Create / Update

[0268] Not implemented, throws an exception.

[0269] As previously mentioned, the example microservices can be stateless in embodiments, thus greatly simplifying their interactions with each other. In some embodiments, a session state microservice is provided to allow access to a distributed object model ("DOM") object maintained on an application session. In an example, a simplified API for the session state microservice is the following interface: sessionDOMGetSessionDOM(), which can return an object that provides a session DOM.

[0270] In an embodiment, a DOM object can be a data structure that collects various data sets that represent the state of a user session logged into the network. The data can be frequently accessed data (e.g., security rules) that is accumulated on demand, or a discrete set of items related to the logged-in user (e.g., current user, language selection, user source, current network visualization report, etc.). According to the microservice architecture, an embodiment includes a single service that reads and updates data in the DOM. When requesting data from the DOM, the network application logic can use the service. In some embodiments, the data in the DOM can be physically anchored to a session state (e.g., maintained by an application server).

[0271] As described herein, trickle feed incremental processing for a network maintains a network configuration for a given organization / entity / node (e.g., a direct access vector for a given node), which can be readily used to query a data store 708 to traverse a graph representing a network of nodes (e.g., to identify existing or potential paths / supply chains that include a given node). An example network traversal microservice for traversing a network to return paths to an organization (e.g., an entity or node in a network) may be provided. A subset of the functionality of the example network traversal microservice is as follows:

[0272] Data Layout

[0273] Simple 4column table (connectionId, to, from, type) with one row per connection. Reverse connections are not stored.

[0274] Given nodes X and Y, where type c = consumes and s = supplies

[0275] X c Y (X consumes Y)

[0276] and

[0277] Y s X (Y supplies X)

[0278] are equivalent.

[0279] Objects

[0280] Network

[0281] IDDRS <organisations>Organisations

[0282] List <connection>connections

[0283] Connections

[0284] Long formNodeId

[0285] Long toNodeId

[0286] Enum connectionType

[0287] API

[0288] public Network readNetwork(Int startOrganisationId,int depth)

[0289] In some embodiments, the network traversal microservice can return a network path (e.g., supply chain) for an organization of the requesting user. For example, the returned data can also represent paths such as pairs of organizations (e.g., identified by ID), in addition to the nature of the relationships connecting these organizations (e.g., trading partners, suppliers, customers, etc.). In some embodiments, the service can be used to display and search the supply chain of an organization.

[0290] The organizations representing the supply chain (returned by the service) can be defined by the connections between them and the goods or products traded. In some embodiments, to deliver the list of connected nodes, the microservice utilizes information about accepted connections and traded products, although in some embodiments, this information is used but not returned. For example, in some embodiments, a result set representing the organizations of the supply chain is returned, but no additional information used to annotate the result set is returned.

[0291] As reference Figure 8-Figure 14 In further detail, visualizations can be displayed to users of the network system, and in some cases, visualizations can include visualizations of data protected using the security policy of the network system, such as visualizations of paths of nodes / entities representing a supply chain. An example visualization microservice for creating, editing, or updating visualizations of the network system can be provided. A subset of the functionality of the visualization microservice is as follows:

[0292] Function:

[0293] Create

[0294] ο Make sure all required attributes are provided

[0295] οCreate a new visualization.

[0296] Read

[0297] ο Read the current visualization for the current organization. Retrieving a visualization in this way will return everything needed to create the visualization in addition to the actual data. This can be used to retrieve and edit visualization specifications without having to read all the network data.

[0298] Reading visualization data

[0299] ο This operation will read the visualization including the actual network data required for the UI display.

[0300] Update

[0301] ο Update visualization with provided data

[0302] Delete

[0303] Remove virtualization from the DOM

[0304] A visualization can be defined as follows:

[0305]

[0306]

[0307] Table 1

[0308] Creation

[0309] Creating a visualization requires providing mandatory properties, otherwise an exception will be thrown. Once a visualization is created, it can be edited. Before the visualization data is displayed, it is looked up via the connection service. At this point, options and filters are taken into account.

[0310] Editing

[0311] Any property can be edited except the ID. Changing a visualization property may require re-reading the data for the change to take effect (e.g., options or filters changed).

[0312] Return to reference Figure 7 , services 702, data platform 704, security platform 706, and data storage 708 may be configured to allow information sharing between entities / nodes / organizations in the network. Even in cases where some of the data is confidential or sensitive, the network system is based on smooth data sharing rather than islands of private data. Thus, network data may be shared between nodes / entities / organizations according to sharing rules based on the relationship between the node / entity / organization requesting access to the data and the node / entity / organization that owns the requested data record.

[0313] The following are examples of sharing rules for a given node / entity / organization: A data record owned by a given entity (e.g., a row of a table) allows access to any entity where an existing flow of goods or products exists for the given entity (e.g., the entity is a trading partner or on a supply chain path), and does not allow access to entities that do not have such existing flows of goods or products. In other words, a given entity may allow trading partners to access certain data that is not accessible to non-trading partners. Different network sharing rules may be defined for different groups of field data (e.g., columns) within the same record (e.g., row). In some embodiments, sharing rules may be defined for individual users of each different functional area of ​​the network system.

[0314] As detailed herein, the entity of the node network may be an organization, and the data storage device 708 may store profile information of the organization. For example, a profile may be stored for a registered organization, which may include one or more of the following: name, address or location (e.g., latitude, longitude, home country, and any other suitable location information), a brand associated with the organization, a home page uniform resource locator ("URL"), social media accounts of the organization, combinations of these, and other suitable information.

[0315] In an embodiment, a network of nodes may represent a network of suppliers, customers, and / or intermediaries. In such an example, an organizational profile may also include one or more of the following: products sold, products purchased, certificates from third-party associations, expired certificates from third-party associations, direct suppliers (e.g., suppliers from other entities in the network), direct customers (e.g., customers from other entities in the network), plans for goods or products (e.g., recipes), parts of goods or products (e.g., ingredients), combinations of these, and any other suitable information for buyers or sellers of products or goods.

[0316] In embodiments that include social aspects of network nodes (e.g., posts, messages, etc.), the system can manage social data of entities, such as messages, posts, discussion groups, and other social interaction data. In addition, entities also include network data related to their orientation in the network, such as connections between entities / nodes, paths with entities / nodes (e.g., direct access vectors), and other suitable information related to the orientation of entities / nodes in the network.

[0317] In some embodiments, an entity may define specific sharing rules for various pieces of data owned by the entity (e.g., different data items related to an organizational profile, social network data, network targeting data, etc.). For example, a portion of an organization's profile may have a public sharing rule (e.g., available to anyone), while a certificate or expired certificate may have a direct trade relationship sharing rule (e.g., available only to trading partners). Example sharing rules are:

[0318] Public — The data is available to anyone on the Internet.

[0319] Web - Data is available to any registered user / organization. Anyone with a user account can log into the system.

[0320] Direct Trading Connection—Data is available to users within organizations that have a direct trading relationship with the source organization. They directly supply, consume, or both to the source organization.

[0321] Customer connection—Data is available to users within organizations that are customers of the source organization.

[0322] Supplier Connection—Data is available to users within organizations that are suppliers to the source organization.

[0323] Potential Connections—Data is made available to users within an organization that has a potential connection (eg, a potential commodity or product flow) to a source organization based on a match between ingredients and recipes owned by the organization (as described herein).

[0324] Specific Organization—Data is available to anyone from a list of specific organizations. You can select the organization from among all organizations on the network.

[0325] Private—Data is available only to users within the organization that owns the data.

[0326] In some embodiments, the security platform 706 makes access permission decisions based on these sharing rules for each source entity (e.g., stored as access permissions) and the relationship between the source entity and the user requesting the source entity's data. The relationship between entities / organizations can be stored as network data. In some examples, the relationship can be defined by sending and accepting invitations to indicate a trading relationship. For example, customer "X" can request organization "Y" to connect with them as a supplier. If the invitation is accepted, then supplier "Y" will be able to see data that owner "X" has marked as "visible only to suppliers".

[0327] In some embodiments, after parsing the data sharing rules and determining whether the user is permitted to retrieve data owned by the source entity, the relationship filter 718 enhances the data query (e.g., SQL query) submitted on behalf of the authenticated user (via the service 702 and the data platform 704) with a "key" to retrieve data from the data store 708. The enhanced query can then be executed at the data store 708 to retrieve the requested data. In some embodiments, in the event that the data store 718 determines that the user is not permitted to access the requested data, the relevant "key" for the data will not be added to the query, and therefore the data will not be returned when the query is executed at the data store 718.

[0328] In some embodiments, the security platform 706 accesses the "currently logged in organization ID". The "currently logged in organization ID" can be immutably stored in the trusted repository 720 through the login process based on the organization associated with the authenticated user. Tables within the data store 708 containing sensitive information (e.g., information protected by one of the security policies / sharing rules described above) can have their records keyed by the organization ID of the entity / organization that is considered to "own" the record. As described above, each entity / organization can grant access rights to various organizations or "organization categories" associated with them in a specific manner based on specific sharing rules / access permissions (e.g., customers, suppliers, etc.).

[0329] In some embodiments, the tables storing network data in the data storage device 708 have an associated "security descriptor" or XML representation of the rules that show how the organization requesting access to the data must relate to the owner of the data row (if the row is to be accessed). For example, the XML can define sharing rules / access permissions for the records of the associated data table. The security platform 706 uses the XML relationship rules and the "currently logged in organization ID" to determine the set of other possible organizations that can access its data.

[0330] In some embodiments, relational filtering 718 modifies the SQL access statement so that an additional WHERE clause modifier is added to any filtering already specified in the SQL (e.g., by the data platform 704). This additional qualifier may list a set of valid organization IDs (e.g., based on the currently logged-in organization ID and the XML security descriptor), one of which must be present in the organization key of the data row in order for the record to match and be included in the scope of the query.

[0331] In some embodiments, after the SQL results are received but before they are returned to the calling application, data reduction can be performed through data collation 716. For example, the WHERE key modification process will limit the rows accessed by the SQL, but the individual fields of these rows will be read without regard to security protocols. In some cases, the data owner may have allowed access to the record, but not all fields in the record. Data collation 716 can be used to handle such scenarios and revise the column-level data.

[0332] In some embodiments, each record returned is post-processed by data collation 716 to remove any field data that is not authorized by the data owner as accessible by the current organization. In some embodiments, a row set (e.g., a returned data set) is returned only after key filtering and collation.

[0333] As an example, a requesting organization / application / microservice may attempt to read a table using an unrestricted "*" SQLwhere clause. The security platform 706 may then use the "currently logged in organization ID" to identify the requester from the trusted repository 720. The security platform 706 may then compute the set of other organizations that have been granted access to that organization. Relationship filtering 718 may add additional WHERE modifiers to the SQL to filter out data owned by organizations that have not been granted that access. Therefore, retrieval from such an unrestricted SQL statement will return a much more secure set of records due to the added WHERE modifiers.

[0334] In some embodiments, data redaction 716 can then analyze the retrieved data to remove any fields that the record's owning organization does not allow the requester to view. For example, for each record, a security protocol (e.g., access permissions / data sharing rules / security descriptor files) can be accessed to determine the column-level access of the requesting organization relative to the record's owner. When it is determined that the requesting organization does not have column-level access rights to the data, the data can be removed from the result set. The relationship-filtered and redacted data can then be returned to the requesting organization. In some embodiments, this may be an empty set of records.

[0335] The following represents an example XML that defines the access permissions used by the security platform 706 to perform the above-mentioned security functions:

[0336] <?xml version="1.0"?>

[0337] <!--Organizations have access to any requests they created (CREATED_ORG_ID) or any requests targeted at the organization but not the user (TARGET_ORG_ID). Users have access to any requests for any organization they are a member of (@SecureAvailableOrganisations) or any requests targeted at the user. Records cannot be deleted. Only the status ID, updated date and time, updated organization ID, and updated user ID can be updated-->

[0338] <SecurityDefinition id="Rdbms_INVITE_STREAM"> <datasources><Rdbms id="InviteStreamDataSource"allowedOperations="Create,Read"source="INVITE_STREAM"> <fields><Field writeValue="@'SecureSelectedOrganisationId'"sourceName="CREATED_ORG_ID"logicalName="CreatedOrgId" / ><Field sourceName="TARGET_ORG_ID"logicalName="TargetOrgId" / ><Field sourceName="TARGET_USER_ID"logicalName="TargetUsrId" / ><Field allowedOperations="Create,Read,Update"writeValue="@CurrentDateTime"sourceName="UPDATED_DATETIME"logicalName="UpdDateTime" / ><Field allowedOperations="Create,Read,Update"writeValue="@'SecureSelectedOrganisationId'"sourceName="UPDATED_ORG_ID"logicalName="UpdatedOrgId" / ><Field allowedOperations="Create,Read,Update"sourceName="STATUS_ID"logicalName="StatusId" / ><Field allowedOperations="Create,Read,Update"sourceName="CODE"logicalName="Code" / >< / fields> < / datasources> <transforms><Filter id="FilteredRequestStreamTransform"input="InviteStreamDataSource"> <clauses> <or> <leftclause><Clause rightValue="@'SecureAvailableOrganisationIds'"relation="="leftValue="CreatedOrgId" / >< / leftclause> <rightclause> <or> <leftclause> <and> <leftclause><Clause rightValue="@'SecureAvailableOrganisationIds'"relation="="leftValue="TargetOrgId" / >< / leftclause> <rightclause><Clause rightValue="NULL"relation="="leftValue="TargetUsrId" / >< / rightclause> < / and> < / leftclause> <rightclause><ClauserightValue="@'SecureUserId'"relation="="leftValue="TargetUsrId" / >< / rightclause> < / or> < / rightclause> < / or> < / Claus es>< / clauses> < / transforms>

[0339] <?xml version="1.0"?>

[0340] <securityconfiguration><Entity defaultSourcePrefix="ORG"knownEntity="Organisation"> <attributes><Attribute logicalName="ProductsPurchased"> <storage><Rdbms source="ORG_PRODUCTS_PURCHASED / ORG_ID" / ><Rdbms source="ORG_PRODUCTS_PURCHASED / PRODUCT_ID" / >< / storage> < / At tribute><Attribute logicalName="ProductsSold"> <storage><Rdbms source="ORG_PRODUCTS_SOLD / ORG_ID" / ><Rdbmssource="ORG_PRODUCTS_SOLD / PRODUCT_ID" / >< / storage> < / attributes> <AttributeGroup name="OrganisationProductsTraded"> <attributes><Attribute id="Organisation / ProductsPurchased" / ><Attribute id="Organisation / ProductsSold" / >< / attributes> <DataEntry caption="_TRANS_ViewProducts Traded"globalDefaultRule="Network"attributeGroupName="OrganisationProductsTraded"> <verbs><Verb name="Read" / >< / verbs> < / securityconfiguration>

[0341] In some embodiments, user-based functional security rules control "who" can do "what" within the source organization. They can also control who has which access rights to the underlying source organization data. Security templates are used to define the functional security that users have when these templates are created. Administrators (users with sufficient privileges) can control whether given users within their organization are granted or revoked permissions through functional security settings. The available security templates and their associated privileges are shown in Tables 2 and 3 below. For example, three templates can be considered: Administrator-users who can fully manage the organization, including managing users, connections, and all data belonging to their organization; User Editor-users who can contribute by posting social posts, managing company profiles, etc., but cannot perform security-related operations such as managing users, connections, etc.; User Reader-users who can only view and analyze information. They cannot make any changes. Generally speaking, this type of user is a read-only user.

[0342]

[0343] Table 2

[0344]

[0345] Table 3

[0346] In some embodiments, the data retrieved from the social network can be used for various functional purposes. For example, one or more visualizations can be generated that illustrate the orientation of an organization in a path (e.g., a supply chain). Figure 8 An example graphical user interface for configuring a view of a network of nodes according to an example embodiment is illustrated. For example, a user within an organization may operate a client device that is configured to display a dashboard 800 for displaying a supply chain visualization. The network data retrieved to generate the visualization may utilize one or more of the disclosed functions. For example, a visualization may be generated based on a vector (e.g., a direct access vector) for a given node retrieved from a precomputed version of the stored network data. The retrieved network data may also be protected using relationship filtering and data redaction functions that manage storage security policies relative to a given node.

[0347] In some embodiments, dashboard 800 may include user interface elements (e.g., widgets) including filter options 802, configuration options 804, enablement 806, depth 808, visualization options 810, and properties 812. For example, filter options 802 may be used to determine the type of filter used for organizational data displayed by the visualization. The illustrated options include a country filter, an organization name filter, a purchased product filter, a sold product filter, an expired certificate filter, a raw material filter (e.g., ingredient), and a product line filter.

[0348] Figure 8 An example is illustrated where "Expired Certificates" is the selected filter. Configuration options 804 may allow configuration of the selected filter. In the illustrated embodiment, the filter is configured to display entities in the supply chain that have greater than "0" expired certificates. Enable 806 allows a user to enable or disable the filter.

[0349] Depth 808 may allow a user to select the depth of the supply chain (e.g., display nodes / entities / organizations that have a distance less than or equal to the selected depth, where distance is the number of jumps or hops away from a source node / entity / organization in the network). Visualization options 810 allow a user to select a visualization type, such as a pie chart, bar chart, network diagram, table, or world map. Fig. 9 Illustrated is a pie chart visualization of network data according to an example embodiment. Fig.10 Illustrated is a table visualization of network data according to an example embodiment. Fig.11 Illustrated is a network graph visualization of network data according to an example embodiment. Figure 12-14 Illustrated is a world view visualization of supply chain data according to an example embodiment.

[0350] Data attributes 812 allow the user to select data attributes to be used by some visualizations. For example, Fig. 9 The pie chart 900 shows a pie chart divided by country. If the user desires a broader data view of the supply chain visualization, then Fig.10 The Data Table 1000 provides a larger cross-section of network data. Fig.11 The network diagram 1100 depicts a visualization of network nodes and connections between these network nodes, which visualization shows the various links included in the supply chain.

[0351] Fig.12 The world view visualization 1200 depicts supply chain connections overlaid on a world map. In this example, various regional risks in the supply chain are shown to the user. The user can further request more granular information about the links in the supply chain by selecting (e.g., clicking or tapping) a point in the supply chain. Fig.13 The world view visualization 1300 includes a widget 1302 , a summary 1304 , and an indicator 1306 that are displayed upon selection of a link in a supply chain.

[0352] Widget 1302 can be used to select organizational information for display. Summary 1304 provides a summary of the selected organization, including a number of expired certificates (e.g., a filter used to generate the depicted visualization). Indicator 1306 can indicate the conditions of a particular filter used to generate the visualization. In the illustrated embodiment, indicator 1306 shows a red exclamation point because the selected organization has an expired certificate. In some examples, if the organization does not have expired certificates, a green check mark can be displayed. Fig.14 Visualization 1400 similarly includes widgets 1402 and summary 1404, which display a summary of different organizations in the supply chain.

[0353] The various disclosed embodiments have many advantages over conventional data management and security applications. For example, embodiments including trickle feed incremental processing and pre-computed versions of network data can greatly reduce the computational complexity associated with traversing large node graphs. At least the generated direct access vectors provide an efficient solution for querying relational databases to quickly and accurately retrieve network data. Such efficiency and high accessibility allow for robust software service products from network systems, such as the visualizations disclosed herein. These benefits cannot be achieved with the more cumbersome, inefficient, and computationally challenging approaches adopted by conventional data management systems.

[0354] For example, some data schema implementations are designed to represent and answer questions on a network of connected graphs. However, many of them have been optimized for frequent reads and occasional updates. In various embodiments, the network may sometimes be subject to frequent updates as new relationship connections and trade goods or products are added / updated between participating organizations. In such an environment, the disclosed trickle feed incremental processing provides technical advantages.

[0355] Another alternative could be a simple on-demand recursion of the relational network connectivity table. Conventional approaches utilizing such simple systems can handle frequent updates, but traversing the graph represented by the stored data can be computationally challenging. A trickle-feed incremental processing solution and precomputed versions of the network data can provide efficient traversal even with frequent updates, yielding performance benefits over those conventional techniques.

[0356] In addition, embodiments including a trusted repository and data security policies ensure that a network of nodes can store and share private, sensitive, or confidential data between different organizations in a supply chain or, in some cases, between potential organizations that may be added to a supply chain. In particular, funneling of data requests through the security subsystem and relationship filtering and data redaction implemented by the security subsystem and trusted repository ensure that no user or organization is provided access to data for which it does not have permission to view, update, or delete.

[0357] For example, traditional role-based security mechanisms typically assume that data access permissions are granted using a fixed list of users or user groups to be granted access. Embodiments provide access based on the "relationship between data owners and data consumers." For example, when granting access to a piece of data to an organization's "customers," the organizations that fall into that "customer" category can change fluidly as the trading relationship is updated, and therefore, the organizations that are authorized to access the data piece can change fluidly. Embodiments provide permission policies that can efficiently and effectively protect data retrieval in the presence of such changes. Additionally, traditional security is also often based on record keys. Embodiments include a finer granularity where security is set independently on each field of a record.

[0358] Fig.15 An example method for managing a network of nodes using incremental processing according to an example embodiment is illustrated. In one embodiment, the following Fig.15 and Fig.16 The functions of the computer program product are implemented by software stored in a memory or other computer-readable or tangible medium and executed by a processor. In other embodiments, each function may be performed by hardware (e.g., by using an application specific integrated circuit ("ASIC"), a programmable gate array ("PGA"), a field programmable gate array ("FPGA"), etc.) or any combination of hardware and software.

[0359] At 1502, a network having a plurality of connected nodes is stored, the nodes representing entities of the network. For example, the network of connected nodes may be mapped onto a relational data table. In an embodiment, the network may be a social network represented by a directed graph.

[0360] At 1504, one or more deltas to a network may be received, the one or more deltas indicating updates to connections between a plurality of nodes. For example, an update to network information may be received from an authenticated user associated with an entity of the network, and one or more deltas may be generated based on the update. At 1506, the deltas may be added to a queue. At 1508, the deltas in the queue may be used to update connections between nodes of the network. For example, the queue may be a FIFO queue, and the delta at the top of the queue may be processed to update the network.

[0361] At 1510, the network can be processed after updating connections between nodes to generate a vector for a given node. For example, the transitive closure of the network can be determined after updating the network, and the transitive closure can be used to generate a direct access vector for each node in the network.

[0362] In some embodiments, trickle feed incremental processing may include storing a precomputed version of network data in a set of relational data tables. For example, based on the precomputed network data stored in the data tables, this precomputed version may provide efficient network traversal. In some embodiments, processing the network may include updating data in one or more data tables storing precomputed versions of the network data. In some embodiments, the precomputed version of the network data provides direct access vectors to network nodes that can be retrieved by querying the data tables. The direct access vectors may indicate connected nodes that include a connection to a given node and indirect nodes that are part of a path that includes the given node and at least one connected node.

[0363] At 1512, one or more paths for a given node may be identified based on the generated vector. For example, a relational data table may be queried using the direct access vector to return path information for a given node. In an embodiment, an identified path including a given node may be created when updating links between nodes of the network.

[0364] In an embodiment, one or more parts and one or more plans including the parts may be defined for a node of a network, and a connection between two nodes of the network may be based on a correspondence between a plan defined for a first of the two nodes and a part defined for a second of the two nodes. For example, a plan may be a recipe, and the parts may be ingredients of the recipe. In an embodiment, entities may include suppliers and customers, and a connection may represent a transaction between entities. For example, an identified path may represent a supply chain for at least one commodity or product. In an embodiment, a transitive closure may be determined using a network connection based on a correspondence between plans and parts connecting nodes.

[0365] Fig.16 An example method for providing secure data management for a network of nodes according to an example embodiment is illustrated. At 1602, a network having a plurality of connected nodes is stored, the nodes representing entities of the network. For example, the network of connected nodes can be mapped to a relational data table. In an embodiment, the network can be a social network represented by a directed graph.

[0366] At 1604, a request to retrieve data about a second node of a network can be received from a first node. For example, the request can be received from an authorized user of an entity represented by the first node. At 1606, a query can be generated to retrieve the requested data.

[0367] At 1608, the query can be filtered based on permissions of the first node stored at the trusted repository. For example, the query can be enhanced with a key for retrieving requested data based on permissions of the first node relative to a second node stored at the trusted repository.

[0368] In some embodiments, a permission file is stored that defines access to one or more relational data tables, and access permissions are defined for each record in the relational data table based on an owner node that owns the record and a relationship between the owner node and a node requesting access. The trusted repository can store multiple keys for network nodes in an unchanging manner. In some embodiments, filtering a query based on permissions of a first node stored in the trusted repository includes accessing the permission file to retrieve a key list from the trusted repository, wherein the key list is for a subset of nodes that are permitted to be accessed by the first node based on a relationship between the first node and the subset of nodes. Strengthening the query can include adding the key list to the query, wherein when the key list includes a key corresponding to a protected record, retrieving a protected record within the relational data table requested by the query.

[0369] In an embodiment, the authenticated user has permission to view at least some data of nodes connected to a first node, the first node being connected to a second node. In an embodiment, the authenticated user has permission to view at least some data of nodes including a path with the first node, the first node being on the path with the second node.

[0370] At 1610, fields in the results of the filtered query can be redacted based on permissions for the first node. For example, a permissions file can be accessed to determine what access permissions the first node has relative to the owner of the returned records. Before returning the query results, any column-level data that the first node is determined not to have access to can be deleted. At 1612, the redacted results can be provided to the first node.

[0371] In an embodiment, the entities represented by the nodes may be suppliers and customers, and the paths between the nodes may represent a supply chain network of one or more products. For example, an authenticated user may have permission to access a supply chain network including a first node, a supplier including the first node, or a customer including the first node.

[0372] Embodiments manage data processing of a network of nodes. An example network may include multiple nodes with multiple connections between them. In some embodiments, the network may be a social network with various degrees of information sharing. Sometimes, a new connection may be generated between two previously unconnected nodes, or a connection between previously connected nodes may be disconnected. One or more paths may be identified based on the current configuration of the network (e.g., the current connections between the nodes). For example, a path may start from a first node and pass through a second node, a third node, and a fourth node before terminating at a fifth node. Such identified paths may be used to identify patterns, trends, or risks, perform predictions, or for other analytical purposes (i.e., depending on the nodes within the network and the specific implementation).

[0373] However, the dynamic nature of these networks presents risks and computational challenges. For example, social networks are constantly changing, building new node connections and tearing down old node connections. Therefore, identifying paths between nodes can be computationally cumbersome. As further detailed herein, embodiments utilize trickle feed incremental processing to manage the network, which achieves computational efficiency while maintaining the dynamic update capability of node connections.

[0374] In some embodiments, entities (e.g., nodes) of a network may have authorized users that interact with the system. For example, an authorized user may edit an entity's profile, send messages to other entities of the network, change relationships with other entities, retrieve data related to entities of the network, perform network analysis, and other suitable functions. However, in some embodiments, confidential or sensitive information of one or more entities may be stored in association with the network (e.g., in a data repository). For example, in a social network, the system may store sensitive information of a first entity that may be shared with a subset of other entities but not with the remaining entities. In other examples, sensitive information may be marked as private and therefore may not be shared with any other entity of the social network.

[0375] In some embodiments, the system can provide secure data retrieval for entities of the network. For example, the security subsystem can maintain one or more permissions for authorized users, which determine what information the user can retrieve. Based on the security subsystem, data retrieval requests can be filtered to ensure that authorized users are only provided with information based on established permissions. For example, before performing a search on a data repository, relationship filtering can be used to filter the generated queries based on permissions. In another example, data redaction can be performed on the data retrieved by the query based on the permissions for redaction data before the data is provided to the authorized user. The security subsystem, relationship filtering, and data redaction can be used to ensure secure data management of sensitive or confidential data of network entities.

[0376] The features, structures or characteristics of the present disclosure described throughout this specification may be combined in any suitable manner in one or more embodiments. For example, throughout the specification, the use of "one embodiment", "some embodiments", "a certain embodiment", "certain embodiments" or other similar language refers to the fact that a particular feature, structure or characteristic described in conjunction with that embodiment may be included in at least one embodiment of the present disclosure. Therefore, the appearance of the phrases "one embodiment", "some embodiments", "a certain embodiment", "certain embodiments" or other similar language throughout this specification does not necessarily all refer to the same set of embodiments, and in one or more embodiments, the described features, structures or characteristics may be combined in any suitable manner.

[0377] Those of ordinary skill in the art will readily appreciate that the embodiments described above may be practiced with steps in a different order and / or with elements in a configuration different from that disclosed. Therefore, while the present disclosure contemplates the embodiments outlined, it will be apparent to those skilled in the art that certain modifications, variations, and alternative configurations will be apparent while remaining within the spirit and scope of the present disclosure. Therefore, in order to determine the scope and limits of the present disclosure, reference should be made to the appended claims.< / connection> < / organisations> < / product> < / organisation> < / t> < / t> < / t> < / t> < / t> < / t> < / t> < / t>

Claims

1. A method for managing a node network using incremental processing, the method comprising: storing a network having a plurality of connected nodes, wherein the plurality of connected nodes represent entities of the network and a precomputed version of the network is maintained; receiving one or more updates to the network; updating a stored network based on the received update, wherein one or more deltas are generated for the update to the network, the update to the network resulting in changes to connections between the plurality of connected nodes; adding the increment to a queue; processing increments from the queue to maintain a precomputed version of the network, wherein the precomputed version of the network and a direct access vector for a given node are configured such that the direct access vector is used to retrieve one or more paths for the given node from a data structure storing the precomputed version of the network; as well as The one or more paths to the given node are identified using the precomputed version of the network based on the direct access vector for the given node. 2 . The method of claim 1 , wherein the network comprises a social network represented by a directed graph.

3. The method of claim 2, wherein maintaining a precomputed version of the network further comprises determining a transitive closure of the network, and wherein the direct access vector for the given node is based on the determined transitive closure of the network.

4. A method as claimed in claim 3, wherein one or more parts and one or more plans including the multiple parts are defined for multiple connected nodes of the network, and wherein the connection between two nodes of the network is based on a correspondence between the plan defined for the first node of the two nodes and the part defined for the second node of the two nodes.

5. The method of claim 4, wherein the transitive closure is determined using connections between the plurality of connection nodes based on a correspondence between plans defined for the plurality of connection nodes and parts defined for the plurality of connection nodes.

6. The method of claim 5, further comprising: After processing the network, a request is received to identify the one or more paths of the network that include the given node.

7. The method of claim 6, wherein after updating the stored network and processing the deltas, creating the identified path including the given node.

8. The method of claim 4, wherein the entities include suppliers and customers, and the connections between the plurality of connection nodes represent transactions between the entities.

9. The method of claim 4, wherein the plan comprises a recipe, the portions comprise ingredients of the recipe, and the identified paths represent a supply chain for at least one good or product.

10. The method of claim 1, wherein the precomputed version of the network is mapped onto a plurality of relational data tables, the plurality of relational data tables comprising a data structure storing the precomputed version of the network.

11. The method of claim 10, wherein the one or more paths for the given node are identified by querying a relationship data table based on the direct access vector for the given node.

12. The method of claim 10, further comprising: Updates to the stored network are tracked to generate the one or more deltas, wherein the one or more deltas are generated when the update to the tracking of the stored network corresponds to a change to a relational data table storing a precomputed version of the network.

13. A method as claimed in claim 12, wherein a given update to a stored network that changes a given connection between two nodes of the network corresponds to a given increment, and the given increment includes one or more updates to a relational data table storing a pre-computed version of the network to reflect the change made to the given connection between two nodes of the network.

14. The method of claim 13, wherein processing the given increment from the queue comprises implementing the one or more updates to the relationship data table to reflect a change to a given connection between two nodes of the network, thereby maintaining a precomputed version of the network.

15. A non-transitory computer-readable medium having instructions stored thereon, which, when executed by a processor, cause the processor to manage a network of nodes utilizing incremental processing, the management comprising: storing a network having a plurality of connected nodes, the plurality of connected nodes representing entities of the network and a precomputed version of the network being maintained; receiving one or more updates to the network; updating a stored network based on the received update, wherein one or more deltas are generated for the update to the network, the update to the network resulting in changes to connections between a plurality of connected nodes; adding the increment to a queue; processing increments from the queue to maintain a precomputed version of the network, wherein the precomputed version of the network and a direct access vector for a given node are configured such that the direct access vector is used to retrieve one or more paths for the given node from a data structure storing the precomputed version of the network; as well as The one or more paths to the given node are identified using the precomputed version of the network based on the direct access vector for the given node.

16. The non-transitory computer-readable medium of claim 15, wherein the network comprises a social network represented by a directed graph.

17. The non-transitory computer readable medium of claim 16, wherein maintaining the precomputed version of the network further comprises determining a transitive closure of the network, and the direct access vector for the given node is based on the determined transitive closure of the network.

18. The non-transitory computer readable medium of claim 15, wherein the precomputed version of the network is mapped onto a plurality of relational data tables, the plurality of relational data tables comprising a data structure storing the precomputed version of the network.

19. The non-transitory computer readable medium of claim 18, wherein the one or more paths for the given node are identified by querying a relationship data table based on the direct access vector for the given node.

20. A system for managing a network of nodes using incremental processing, comprising: A processing device in communication with a memory device, the processing device configured to manage a network of nodes using incremental processing, the management comprising: storing a network having a plurality of connected nodes, the plurality of connected nodes representing entities of the network and a precomputed version of the network being maintained; receiving one or more updates to the network; updating a stored network based on the received update, wherein one or more deltas are generated for the update to the network, the update to the network resulting in changes to connections between a plurality of connected nodes; adding the increment to a queue; processing increments from the queue to maintain a precomputed version of the network, wherein the precomputed version of the network and a direct access vector for a given node are configured such that the direct access vector is used to retrieve one or more paths for the given node from a data structure storing the precomputed version of the network; and The one or more paths to the given node are identified using the precomputed version of the network based on the direct access vector for the given node.

21. An apparatus comprising means for performing the method of any one of claims 1-14.

Citation Information

Patent Citations

  • Microservices based multi-tenant identity and data security management cloud service

    US9838376B1

  • Directed Graph Transitive Closure

    US20120254254A1

  • Data Infrastructure and Method for Ingesting and Updating A Continuously Evolving Social Network

    US20170270210A1