# Patent

## Title
Transaction allocation

## Abstract

Systems and methods of allocating transactions among business objects are described. Allocation is accomplished using a multi-phase process. In a first phase, allocation of the transactions among a set of business objects is attempted. In a subsequent phase, allocation of transactions that were either unallocated, under-allocated, or over-allocated in the first phase is determined. The second phase includes using a set of allocation rules to identify business objects configured to manually determine allocation of the unallocated, under-allocated, or over-allocated transactions. The invention is applicable to a variety of business objects including people, organizations, accounts, tasks, or the like.

## Background
CROSS-REFERENCES TO RELATED APPLICATIONS
This application is a divisional of U.S. patent application Ser. No. 10/691,941, entitled “Transaction Allocation,” filed on Oct. 22, 2003, which is a continuation-in-part of U.S. patent application Ser. No. 10/426,474, entitled “Hierarchical Transaction Filtering,” filed on Apr. 29, 2003, each of which are hereby incorporated herein by reference.


BACKGROUND OF THE INVENTION
1. Field of the Invention
The invention is in the field of computer science and more specifically in the field of transaction management.
2. Description of the Prior Art
In a typical organization, sale of a product or service can impact multiple parties. For example, in a business environment such transactions may involve a sales team, their supervisors, their supporters and post sale personnel. In some cases it is desirable to distribute credit (e.g., commissions) for a sale or responsibility for a purchase, among these parties.
Available software includes applications configured to track sales and distribute commissions to personnel within an organization. In these applications different personnel are assigned various allocation criteria for use in determining the transactions for which they should receive credit. For example, a sale may be associated with a specific sales territory, a specific product type, a sales team, an individual salesperson, a channel partner, a price range, a payment schedule, etc. Each of these characteristics may be associated with allocation criteria and used to determine one or more individuals who should receive credit for the sale.
In a typical prior art application, each transaction is individually examined and its characteristics are compared with each person's allocation criteria. When the characteristics match the criteria, the person receives some credit for the transaction. In large organizations, these comparisons may include thousands of transactions and hundreds of personnel. The total number of comparisons is, therefore, large.
Previously available systems have a number of drawbacks. For example, since each transaction is individually examined, the performance of these systems responds poorly to increases in transaction volume. In addition, setup and maintenance of prior art systems are difficult since each person's allocation criteria is manually defined. Likewise, changes in products, personnel or organization structure can require, possibly extensive, modification of system data. For example, when a new product is introduced the allocation criteria relating to each person who may receive credit for a sale of the product may need to be modified before an appropriate credit can be assigned. Finally, in existing systems, the ways in which credits are assigned can be unclear to personnel tracking or expecting to receive commissions. These systems often do not lend themselves well to the generation of reports that itemize the commissions due to each person.
There is a need for systems and methods to more efficiently manage allocation of transactions, such as sales commissions. For example, there would be a benefit to having systems capable of processing large numbers of transactions more efficiently, automating aspects of allocation criteria management, or more clearly showing to a sales person how their commission was calculated.
Many systems and methods of allocating transactions include a problem of transactions that are unallocated, under-allocated, or over-allocated. For example, in some cases a sales transaction fails to meet the allocation criteria of any person to whom commission might be paid. In some cases, a sales transaction meets the allocation criteria of some people but not enough people to completely allocate the available commission. The existing art does not include efficient methods for allocating transactions that are unallocated, under-allocated or over-allocated.
BRIEF SUMMARY OF THE INVENTION
Embodiments of the invention include systems and methods of allocating transactions among a number of business objects. These business objects include, for example, individuals and/or organizations. The transactions typically involve payment of funds, such as sales commissions, but may also include allocation of inventory, movement of goods, or the like, as discussed further herein. Allocation is accomplished using predefined rules stored in a hierarchical data structure that is based on relationships between the business objects. The predefined rules and hierarchical data structure are used to form generated allocation rules associated with the business objects. The generated allocation rules are, in turn, used for allocating the transactions among the business objects. Each of the allocated transactions includes characteristics that can be determined to satisfy or not to satisfy a generated allocation rule. For example, in some embodiments, the business objects include individuals and groups within a company, the hierarchical data structure is based on the company organization and the generated allocation rules are used to determine sales commissions earned by each business object.
Various embodiments of the invention include transaction filtering system for allocating transactions among a plurality of business objects, the system comprising storage configured to store generated allocation rules and to store transaction data associated with the plurality of transactions, each generated allocation rule being associated with at least one of the plurality of business objects and being generated using relationships between members of the plurality of business objects, and a query engine configured to query the transaction data using the generated allocation rules.
Various embodiments of the invention include a hierarchical data structure comprising a root node, one or more intermediate nodes related to the root node, one or more predefined rules, each predefined rule associated with a member of the one or more intermediate nodes, a leaf node, and a generated allocation rule associated with the leaf node and configured for use in determining allocation of transactions to a business object associated with the leaf node, the generated allocation rule including a member of the one or more predefined rules inherited from the one or more intermediate nodes.
Various embodiments of the invention include a computing system for hierarchical transaction filtering, the computing system comprising storage configured to store a hierarchical data structure, a generated allocation rule, and transaction data, a rule generation engine configured to produce the generated allocation rule using data stored in the hierarchical data structure, and a query engine configured to query the transaction data using the generated allocation rule.
Various embodiments of the invention include a transaction allocation output comprising a set of transactions selected using a query, the query based on a generated allocation rule generated using a hierarchical data structure and associated with a leaf of the hierarchical data structure, at least two transactions of the set of transactions including a transaction value, and a summation of the transaction values.
Various embodiments of the invention include a method of producing a generated allocation rule, the method comprising accessing a data structure including a root node, an intermediate node and a leaf node, reading the root node of the data structure, adding any predefined rule associated with the root node to the generated allocation rule, traversing the data structure to the intermediate node, reading the intermediate node, adding any predefined rule associated with the intermediate node to the generated allocation rule, traversing the data structure to the leaf node, adding any predefined rule associated with the leaf node to the generated allocation rule, and storing the generated allocation rule.
Various embodiments of the invention include a method of producing a plurality of generated allocation rules, the method comprising accessing a hierarchical data structure including a plurality of nodes, and traversing the plurality of nodes, at each node traversed, reading the traversed node, combining any predefined rule associated with the traversed node with any of the plurality of generated allocation rules inherited from a parent node, to produce another of the plurality of generated allocation rules, associating the another of the plurality of generated allocation rules with the traversed node, storing the another of the plurality of generated allocation rules, and determining if all leaf nodes have been traversed.
Various embodiments of the invention include a method of determining allocation of a plurality of transactions, the method comprising receiving first transaction data characterizing a first member of the plurality of transactions, receiving second transaction data characterizing a second member of the plurality of transactions, storing the first and second received transaction data, accessing a plurality of generated allocation rules, each of the plurality of generated allocation rules being associated with one of a plurality of business objects represented by an hierarchical data structure, executing a plurality of queries on the stored transaction data using a query engine, each of the plurality of queries being based on one of the plurality of generated allocation rules, and storing results of the executed queries.
Various embodiments of the invention include a method of generating a transaction allocation output, the method comprising receiving a query result including one or more transactions, the query result generated using a query, the query generated using a hierarchical data structure and the query associated with a leaf node of the hierarchical data structure, the query applied to a set of transactions, parsing each of the one or more transactions to determine a value of each of the one or more transactions, summing the values determined by parsing each of the one or more transactions, and including the sum of the determined values in the transaction allocation output.
Various embodiments of the invention include a system for determining allocation of a plurality of transactions among a plurality of business objects, the system comprising storage configured for storing transaction data characterizing the plurality of transactions, means for producing a plurality of generated allocation rules, using relationships between nodes of a data structure, means for executing a plurality of queries on the stored transaction data, using the plurality of generated allocation rules.
Various embodiments of the invention include a computer readable medium storing computer code for producing a generated allocation rule, the computer code comprising a code segment for accessing a data structure including a root node, an intermediate node and a leaf node, a code segment for reading the root node of the data structure, a code segment for adding any predefined rule associated with the root node to the generated allocation rule, a code segment for traversing the data structure to the intermediate node, a code segment for reading the intermediate node, a code segment for adding any predefined rule associated with the intermediate node to the generated allocation rule, a code segment for traversing the data structure to the leaf node, a code segment for adding any predefined rule associated with the leaf node to the generated allocation rule, and a code segment for storing the generated allocation rule.
Various embodiments of the invention include a method of producing a generated allocation rule, the method comprising accessing a data structure including a root node, an intermediate node and a leaf node, reading the root node of the data structure, adding any predefined rule associated with the root node to the generated allocation rule, traversing the data structure to the intermediate node, reading the intermediate node, adding any predefined rule associated with the intermediate node to the generated allocation rule, traversing the data structure from the intermediate node, reading the leaf node, adding any predefined rule associated with the leaf node to the generated allocation rule, and storing the generated allocation rule. In some of these embodiments, traversing the data structure from the intermediate node includes traversing the data structure to the leaf node. In some of these embodiments, traversing the data structure from the intermediate node includes traversing the data structure to the root node.
Various embodiments of the invention include a transaction filtering system for allocating transactions among a plurality of business objects, the system comprising storage configured to store generated allocation rules and to store transaction data associated with the plurality of transactions, each generated allocation rule being associated with at least one of the plurality of business objects and being generated using relationships between members of the plurality of business objects, a query engine configured to query the transaction data using the generated allocation rules, and an allocation manager configured to make one or more attempts to allocate a member of the plurality of transactions among the plurality of business objects.
Various embodiments of the invention include a hierarchical data structure comprising a root node, one or more intermediate nodes related to the root node, a leaf node, and a first generated allocation rule associated with the leaf node and configured for use in determining allocation of transactions to a business object associated with the leaf node, a second generated allocation rule associated with one of the one or more intermediate nodes and configured for use in determining a business object configured to manually determine the allocation of one of the transactions to a business object.
Various embodiments of the invention include a computing system for hierarchical transaction filtering, the computing system comprising storage configured to store a hierarchical data structure, a first generated allocation rule, a second generated allocation rule, and transaction data, an allocation manager configured to track allocation of transactions represented by the transaction data, and a query engine configured to execute a first query on the transaction data using the first generated allocation rule and, responsive to the first query, to execute a second query on the transaction data using the second generated allocation rule.
Various embodiments of the invention include a transaction allocation output comprising a first set of transactions selected using a first query, the first query based on an allocation rule generated using a hierarchical data structure and associated with a leaf node of the hierarchical data structure, at least one transaction of the first set of transactions including a transaction value, a second set of transactions whose allocation is determined by a business object, the business object being identified using a second query, at least one transaction of the second set of transactions including a transaction value, and a summation of the transaction values.
Various embodiments of the invention include a method of determining allocation of one or more transactions, the method comprising accessing a first allocation rule associated with one of a plurality of business objects represented by a hierarchical data structure, executing a first query on transaction data using a query engine, the first query being based on the first allocation rule, the transaction data characterizing the one or more transactions, accessing a second allocation rule associated with another of the plurality of business objects represented by the hierarchical data structure, and executing a second query on a subset of the transaction data using the query engine, the second query being based on the second allocation rule and identifying a business object for determining allocation of at least one of the one or more transactions.
Various embodiments of the invention include a method of generating a transaction allocation output, the method comprising receiving a query result including one or more transactions, the query result generated using a query applied to a set of transactions, the query generated using a hierarchical data structure and the query associated with a leaf node of the hierarchical data structure, determining transaction allocation of any of the one or more transactions that are unallocated, under-allocated, or over-allocated, parsing each of the one or more transactions to determine a value of each of the one or more transactions, summing the values determined by parsing each of the one or more transactions, and including the sum of the determined values in the transaction allocation output.
Various embodiments of the invention include a system for determining allocation of a plurality of transactions among a plurality of business objects, the system comprising, storage configured for storing transaction data characterizing the plurality of transactions, means for executing a plurality of queries on the stored transaction data, using a plurality of allocation rules, the queries configured to determine allocation of the plurality of transactions, and means for manually determining allocation of a subset of the plurality of transactions, the subset including unallocated, under-allocated or over-allocated transactions.
Various embodiments of the invention include a computer readable medium storing computer code for determining an allocation plan, the computer code comprising a code segment for accessing a first allocation rule associated with one of a plurality of business objects represented by a hierarchical data structure, a code segment for executing a first query on transaction data using a query engine, the first query being based on the first allocation rule, the transaction data characterizing the one or more transactions, a code segment for accessing a second allocation rule associated with another of the plurality of business objects represented by the hierarchical data structure, and a code segment for executing a second query on a subset of the transaction data using the query engine, the second query being based on the second allocation rule and identifying a business object for determining allocation of at least one of the one or more transactions.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 illustrates a hierarchical transaction filtering system according to various embodiments of the invention;
FIG. 2 illustrates hierarchical relationships between a set of business objects according to various embodiments of the invention;
FIG. 3 illustrates a method of determining a generated allocation rule according to various embodiments of the invention;
FIG. 4 illustrates an alternative method of determining a generated allocation rule according to various embodiments of the invention;
FIG. 5 illustrates a method of allocating a plurality of transactions according to various embodiments of the invention;
FIG. 6 illustrates a method of generating a transaction allocation output according to various embodiment of the invention;
FIG. 7 illustrates a hierarchical data structure according to various embodiments of the invention; and
FIG. 8 illustrates a method of allocating transactions according to various embodiments of the invention.



DETAILED DESCRIPTION OF THE INVENTION
Embodiments of the invention include systems and methods of generating allocation rules and using these generated allocation rules to allocate transactions, such as payment of sales commissions, among members of an organization. Each of these members are represented by a node in a hierarchical data structure and are optionally associated with some predefined rule (e.g., allocation criteria). Generated allocation rules, used for performing an allocation, are produced using the predefined rule and associations implied by the hierarchical data structure. For example, in some embodiments, each node in the hierarchical data structure is associated with a generated allocation rule produced by combining any associated predefined rule with a generated allocation rule inherited from a parent node. Through this process of inheritance and combination, a generated allocation rule is determined for each node in the hierarchical data structure. These generated allocation rules are then used to select transactions to be allocated to the members associated with the nodes of the hierarchical data structure.
In a typical embodiment, each member of an organization is treated as a business object associated with a node in the hierarchical data structure. Generated allocation rules, associated with the node and the business object, are derived through a process that includes combining any predefined rule characterizing the business object with any allocation rule (e.g., generated allocation rule) inherited from a parent node. Through inheritance of allocation rules, each node (other than a root node) is associated with a generated allocation rule that is an aggregation of the predefined rule associated with its parent nodes, and grandparent nodes, etcetera, in the hierarchical data structure. Generated allocation rules are produced as the hierarchical data structure is developed or by traversing the hierarchical data structure in an orderly manner. When a business object is not characterized by any predefined rule, the generated allocation rule associated with the business object, and corresponding node, is determined by inheritance from a parent node.
In a typical method of the invention, sales data are received and stored in a database as transactions to be allocated. In order to allocate these transactions among business objects, the database is queried using queries based on the generated allocation rules. Each query is used to select those transactions that satisfy the predefined rules included in a particular generated allocation rule and the selected transactions are allocated to a business object associated with that generated allocation rule. Thus, a particular person is allocated transactions whose characteristics match the generated allocation rule associated with that person, and the allocated transactions are selected using a query based on the associated generated allocation rule. Using this approach, a large number of transactions can be allocated using a small number of queries, because the number of queries is responsive to the number of business objects not the number of transactions. When the number of transactions significantly outnumbers the number of business objects, this approach is typically more efficient than individually comparing each transaction with a set of allocation rules.
In various embodiments, business objects include individual persons, groups, organizations, corporations, geographic locations, projects, products, production resources, tasks, or the like. In these embodiments, transactions optionally include sales, sales commissions, purchases, purchase costs, inventory allocation, allocation of financial resources, allocation of capital resources, tasks, steps in a process, compensation, quality control, billing, or the like. For example, in one embodiment the business object is a task and the transaction is an inventory allocation to that task. In another embodiment, the business object is a person and the transaction is a task (e.g., a sales call) that can be assigned to a person. In another embodiment the business object is a shipping resource (e.g., a cargo carrier) and the transaction is a transportation task. In some embodiments, the transactions include sales and associated sales commissions, and the business objects include members of a sales team and associated parties. For the purposes of example, these embodiments will be discussed further herein. However, the methods and systems discussed in relation to these embodiments are readily applied to alternative embodiments of the invention including other types of business objects and transactions, without going beyond the intended scope of the invention.
In many businesses, sales are achieved as the result of a team effort involving sales personnel, marketing personnel, channel partners, sales engineers and managers. When a sale occurs, a commission or other credit is to be allocated among the parties who contributed to the sale. Typically, each party (e.g., business object) is associated with a generated allocation rule or set of generated allocation rules that determine if the party is entitled to an allocation from a particular sale. Each sale (e.g., transaction) is characterized by attributes that can be compared with the generated allocation rules. For example, a particular sales person may be associated with a generated allocation rule that specifies allocation of 2% of sales revenue within a particular geographic region, 1% of sales from a particular product line, 2% of sales to a particular customer, and 0.5% of sales by other members of her sales team. In this example, a transaction may be characterized by a geographic location, a product, a customer and a sales team. A wide variety of such allocation schemes are known in the art. In the invention, these schemes are expressed as generated allocation rules derived from a hierarchical data structure. Each condition, such as “2% of sales to a particular customer,” is considered a predefined rule.
FIG. 1 illustrates a Transaction Filtering System 100 according to various embodiments of the invention. Transaction Filtering System 100 includes a Computing System 110 optionally accessible through a Client 120 and configured to receive transactions from a Transaction Source 130. Computing System 110 may be a single computing device or a set of interconnected computing devices. The set of interconnected computing devices optionally includes both local and remote devices. In typical embodiments, Client 120 includes a computing device such as a computer, personal digital assistant, network access device, or the like. Client 120 optionally accesses Computing System 110 though a network such as the Internet, local area network, wide area network, or the like. In some embodiments, Computing System 110 is accessed through a browser supported by Client 120.
Transaction Source 130 is a source of transactions to be allocated. For example, in various embodiments, Transaction Source 130 is a point-of-sale system, an accounting system, a sales reporting system, an inventory system, a task management system, or the like. Transaction Source 130 is optionally supported by elements of Computing System 110. For example, in some embodiments, Transaction Source 130 includes a sales accounting program executing on Computing System 110.
Computing System 110 includes Storage 140 configured to store data associated with systems and methods of the invention. For example, Storage 140 is typically configured to store Organizational Data 145, Rule Data 150 and Transaction Data 155. Organizational Data 145 includes a hierarchical data structure configured to store relationships between business objects. An example of Organizational Data 145 is illustrated by FIG. 2 as discussed further herein. Rule Data 150 includes generated allocation rules associated with business objects characterized by information within Organizational Data 145. These generated allocation rules are produced using a Rule Generation Engine 160. The generation process is further described with reference to FIGS. 3 and 4. Transaction Data 155 includes transactions received from Transaction Source 130. In a typical embodiment, a plurality of transactions are stored in Transaction Data 155.
A Query Engine 170 is configured to execute queries based on Rule Data 150. In a typical embodiment, each generated allocation rule within Rule Data 150 is processed to place the generated allocation rule in a structured query language (SQL) format. In some embodiments, the generated allocation rules are stored in Rule Data 150 as SQL queries and can be used by Query Engine 170 without modification. The generated allocation rule based queries are used to select transactions stored in Transaction Data 155.
Results of queries executed using Query Engine 170 are passed through an Output Interface 180 to generate a transaction allocation output that is optionally accessible to Client 120. Output Interface 180 is optionally configured to format the results in a report format including data such as a summation of selected transaction values. In some embodiments, the transaction allocation output is generated in a meta-language format such as HTML, or the like.
Query Engine 170 and optionally Output Interface 180 are responsive to an Allocation Manager 190. Allocation Manager 190 includes computer code configured to manage and optionally coordinate the functions carried out by other aspects of Computing System 110. For example, in some embodiments, Allocation Manager 190 keeps track of the progress made in allocating a set of transactions according to an allocation plan. An allocation plan is a plan for allocating transactions to/among a set of business objects. In some embodiments, Allocation Manager 190 is configured to make several attempts to allocate a particular transaction. In some embodiments, Allocation Manager 190 tracks unallocated transactions, under-allocated transactions, and/or over-allocated transactions.
FIG. 2 illustrates a Hierarchical Data Structure, generally designated 200, according to some embodiments of the invention. In these embodiments, Hierarchical Data Structure 200 is included in Organizational Data 145 (FIG. 1) and is used to store relationships between a set of Business Objects, 210A-210W. Business Objects 210A-210W include geographic regions (210A-210F), sales channel types (210G-210H), product types (2101-210J), individual sales people (210K-21OW), or the like. In this example, Business Object 210A is represented by a root node of Hierarchical Data Structure 200. Business Objects 210B-210J and 210P are represented by intermediate nodes and Business Objects 210K-210N and 210Q-21OW are represented by leaf nodes.
In some embodiments, an individual sales person is optionally associated with more than one Business Object 210. For example, a sales person may be involved with both direct sales in the west and hardware sales in Ohio, and thus be both Business Objects 210K and 210T. A sales person is also optionally represented by an intermediate node such as Business Object 210P. The relationships between Business Object 210P (intermediate node) and Business Objects 210Q-210S (leaf nodes) may, for example, be that of sales group leader and sales group members. Some of Business Objects 210A-210W are optionally representative of different organizations (e.g., companies, divisions, or groups). For example, Business Objects 210M-210S may be representative of a separate channel partner company.
In a typical embodiment, each of Business Objects 210A-210W is associated with at least one generated allocation rule. These generated allocation rules are produced by Rule Generation Engine 160 (FIG. 1) using an inherited allocation rule and any predefined rule characterizing a particular member of Business Objects 210A-210W. For example, Business Object 210B inherits a generated allocation rule from Business Object 210A. In the illustrated example this generated allocation rule may be “a sale within the United States territory.” In addition, Business Object 210B is characterized by a predefined rule “a sale within the West territory.” The generated allocation rule associated with Business Object 210B may, therefore, be the combination of the inherited rule and the predefined rule, resulting in a generated allocation rule of “a sale within the United States territory and a sale within the West territory.” Likewise, generated allocation rules for Business Objects 210G and 210H may be “a sale within the United States territory, a sale within the West territory and a direct sale” and “a sale within the United States territory, a sale within the West territory and a channel partner sale,” respectively.
The embodiment of Hierarchical Relationship Structure 200 illustrated in FIG. 2 includes a single parent node for each node other than the root node (Business Object 210A). This structure simplifies inheritance of generated allocation rules from each parent node to each daughter node. However, in alternative embodiments, any of Business Object 210B-210W may appear more than once in Organizational Data 145. In some embodiments, a particular Business Object 210 inherits generated allocation rules from more than one parent node. The inheritance approach to production of generated allocation rules, as employed by Rule Generation Engine 160, is possible as long as there are a finite number of paths between each node and the root node, (i.e., no circular paths exist). Thus, while a hierarchical data structure is disclosed for illustrative purposes, embodiments of the invention include other relational data models accommodating the principle of inheritance. In some embodiments, of the invention, not all nodes are associated with a member of Business Objects 210A-210W. For example, some data structures, such as a binary tree representation of Hierarchical Data Structure 200, include nodes used primarily for navigation. In some embodiments, only leaf nodes are associated with a member of Business Objects 210A-210W and intermediate nodes are used for navigating the data structure. Even when not associated with a member of Business Objects 210A-21OW, a node may optionally be associated with a predefined allocation rule.
FIG. 3 illustrates a method of determining a generated allocation rule according to various embodiments of the invention. In an optional Generate Hierarchical Data Structure Step 300, Organizational Data 145, such as that illustrated in FIG. 2 is generated and stored in Storage 140. This step includes establishing hierarchical relationships between Business Objects 210A-210W and/or defining predefined rules characterizing Business Objects 210A-210W. This step may be avoided when previously existing data is used. Generate Hierarchical Data Structure Step 300 is optionally an ongoing process wherein Organizational Data 145 is updated by addition, deletion or other modification of Business Objects 210A-210W, over time.
In a Read Root Node Step 310, a root node of Hierarchical Data Structure 200 (e.g., the node representing Business Object 210A) is accessed using Rule Generation Engine 160. From this node all the nodes within Organizational Data 145 are accessible. In some embodiments, this access includes passing a pointer referencing a memory location wherein Business Object 210A is stored, to Rule Generation Engine 160. Read Root Node Step 310 typically includes reading any predefined rule characterizing Business Object 210A.
In an Add Root Node Criteria Step 320, any predefined rule characterizing Business Object 210A is added to the allocation rule being generated. The result of this addition is a generated allocation rule, for the root node, and associated with Business Object 210A. After this step, the generated allocation rule associated with Business Object 210A may include only the predefined rule characterizing Business Object 210A, or alternatively, may also include a default predefined rule introduced by Rule Generation Engine 160. This predefined rule may include, for example, filtering criteria based on the characteristics of the transaction (such as sales amount), or characteristics of the business object (such as product cost).
In a Traverse to Node Step 330, Hierarchical Data Structure 200 is traversed to another node representing one of Business Objects 210B-210W. Traversal of Organizational Data 145 is typically accomplished using one of the many algorithms known in the art for navigating a data structure. Once Rule Generation Engine 160 traverses to a node within Organizational Data 145 that node is considered the “current” node upon which Rule Generation Engine 160 performs operations. In Read Node Step 340, any predefined rule associated with the current node is read by Rule Generation Engine 160.
In an Add Node Criteria Step 350 the read predefined rule is added to any generated allocation rule inherited from a parent node of the current node. Typically, each node other than the root node has one parent node from which a generated allocation rule is inherited. The combination of the inherited generated allocation rule and the read predefined rule forms a generated allocation rule for the current node and any associated member of Business Objects 210B-210W. In alternative embodiments, a node may inherit allocation rules from more than one parent node. In these embodiments, the generated allocation rule for the current node is the combination of all inherited allocation rules and any read predefined rules.
In a Store Allocation Rule Step 360, the generated allocation rule associated with the node is stored in Rule Data 150 (FIG. 1). The storage is optionally in a format accessible to Query Engine 170. In some embodiments, Query Engine 170 is configured to generate a query based on each of the stored rules and in other embodiments the rules are stored directly as formatted queries. In alternative embodiments, the generated allocation rules are stored in Rule Data 150 after each rule is completed.
As determined in a Step 370, if there are further nodes, that have not been read using Read Node Step 340, then the method returns to Traverse to Node Step 330. This process is typically repeated until all nodes have been visited.
FIG. 4 illustrates an alternative method of determining a generated allocation rule according to various embodiments of the invention. In this embodiment, generated allocation rules are produced during development of Hierarchical Data Structure 200. In a Define Root Node Step 410, a root node associated with Business Object 210A is defined. This node serves as a root for Hierarchical Data Structure 200, including nodes associated with Business Objects 210A-210W. Define Root Node Step 410 optionally includes specification of a predefined rule characterizing Business Object 210A.
In an optional Define Root Node Allocation Rule Step 420, Rule Generation Engine 160 is used to define a generated allocation rule associated with the root node. The generated allocation rule is produced by combining any default rule received from Rule Generation Engine 160 with any predefined rule specified in Define Root Node Step 410.
In a Define Daughter Node Step 430, a daughter node, optionally associated with a member of Business Objects 210B-210W, is defined. The daughter node may be either an intermediate node or a leaf node. The first time Define Daughter Node Step 430 is executed the defined node will be a daughter of the root node. In subsequent executions, the defined node may be a daughter of either the root node or an intermediate node. Define Daughter Node Step 430 optionally includes specification of a predefined rule characterizing a member of Business Objects 210B-210W associated with the defined daughter node.
In an Inherit Rule Step 440, the daughter node, defined in Define Daughter Node Step 430, inherits a generated allocation rule from its parent node. In alternative embodiments, the daughter node has more than one parent node and optionally inherits a generated allocation rule from each parent node.
In a Modify Rule Step 450, the inherited allocation rule is modified by adding any predefined rule characterizing the member of Business Objects 210B-210W associated with the defined daughter node. The result of this addition is a new generated allocation rule associated with the daughter node. Steps 430 through 450 are repeated as needed as new nodes and associated Business Objects 210B-210W are added to Hierarchical Data Structure 200.
The methods illustrated in FIG. 3 and FIG. 4 are optionally both used in the same embodiments of the invention. For example, in some embodiments, the method illustrated by FIG. 4 is used when Hierarchical Data Structure 200 is first developed and the method illustrated by FIG. 3 is used to update generated allocation rules if Hierarchical Data Structure 200 has been modified. This modification optionally includes, for example, addition or deletion of nodes, changes in predefined rules, changes in associations between nodes and/or Business Objects 210A-210W, or the like. In various embodiments, data generated in Define Root Node Step 410 and Define Daughter Node Step 430 are stored in Organizational Data 145 (FIG. 1), while data generated in Define Root Node Allocation Rule Step 420 and Modify Rule Step 450 are stored in Rule Data 150.
FIG. 5 illustrates a method of allocating a plurality of transactions according to various embodiments of the invention. In a Receive Transactions Step 510 transaction data characterizing transactions are received from Transaction Source 130 (FIG. 1). For example, in some embodiments, Transaction Source 130 includes records of sales entered by individual sales personnel or their managers. In a Store Transactions Step 520, the transactions received in Receive Transactions Step 510 are stored in Storage 140 as Transaction Data 155. In some embodiments, this storage is accomplished using an SQL compatible database. Typically, a number of transactions are stored before completion of Receive Transactions Step 510 and Store Transactions Step 520. In some embodiments, because the number of queries made to allocate the stored transactions is based upon the number of generated allocation rules used for allocating those transactions, rather than upon the number of transactions, further benefit is achieved when the number of transactions is greater than the number of generated allocation rules.
In an Access Rules Step 530, Query Engine 170 is used to access Rule Data 150 and the generated allocation rules stored therein. The accessed generated allocation rules include those generated allocation rules produced using Organizational Data 145 and Rule Generation Engine 160. In an Execute Queries Step 540, Query Engine 170 is used to perform queries on the transactions received in Receive Transactions Step 510. These queries are based on the generated allocation rules accessed in Access Rules Step 530. In some embodiments, the generated allocation rules are retrieved in a query format, such as SQL, while in other embodiments the generated allocation rules are formatted in Execute Queries Step 540 to form queries for execution. In some embodiments, a query is executed for each generated allocation rule. In some embodiments, a query is executed for each generated allocation rule associated with a leaf node. For example, in embodiments of Hierarchical Data Structure 200, wherein only leaf nodes are used to represent Business Objects 210A-210W, only the generated allocation rules associated with these leaf nodes are needed for allocation.
In an optional Store Query Result Step 550, results of queries executed in Execute Queries Step 540 are stored. Storage may occur on Storage 140, Client 120, or another computing device. Typically, the query results include those transactions that match the generated allocation rules associated with each of Business Objects 210A-210W. Each query executed in Execute Queries Step 540 serves to select transactions to be allocated to a member of Business Objects 210A-210W. In some embodiments, a transaction can be allocated to more than one member of Business Objects 210A-210W.
In the method illustrated by FIG. 5, transactions are optionally allocated in separate stages. For example, in one embodiment wherein Business Object (Channel Partner) 210H (FIG. 2) is a separate company, a benefit is achieved by allocating transactions to Business Object 210H and then allowing the separate company to allocate these transactions among Business Objects 210M-210S in a separate stage. Thus, each allocation is optionally viewed as a Transaction Source 130 to a separate stage of the invention. In one embodiment, the generated allocation rules used to allocate transactions to Business Object 210H are not revealed to Business Object 210H. Furthermore, in one embodiment, only transactions allocated to Business Object 210H are revealed to Business Object 210H.
FIG. 6 illustrates a method of generating a transaction allocation output according to various embodiment of the invention. In a Receive Query Result Step 610 a query result, including selected transactions, is received. This query result is, for example, a query result stored in Store Query Result Step 550 of FIG. 5. The received query result is generated using a query based on a hierarchical organizational data (e.g., Hierarchical Data Structure 200). Examples of steps included in this generation process are illustrated by FIG. 3 and FIG. 4.
In a Parse Transactions Step 620, the selected transactions received in Receive Query Result Step 610 are parsed. During the parsing process transaction values are identified. In various embodiments, these transaction values are, for example, the amount of a sale, the amount of a sales commission, the amount paid by a customer, the cost of a sale, an inventory allocation, or the like.
In a Sum Transaction Values Step 630 the transaction values identified in Parse Transactions Step 620 are summed. In alternative embodiments, alternative or additional mathematical operations are performed on these transaction values. In an Include Sum Step 640, the result of the mathematical operation, performed in Sum Transactions Values Step 630, are included in the transaction allocation output. In various embodiments, of the invention, the transaction allocation output is a printed output, a display output, a digital electronic output, a saved output, or the like. For example, in some embodiments, the transaction allocation output is displayed and/or printed using Client 120.
FIG. 7 illustrates an alternative Hierarchical Data Structure, generally designated 700, including Root Node 710, Intermediate Nodes 720A-720H, and Leaf Nodes 730A-730N. In Hierarchical Data Structure 700, business objects configured to receive transaction allocations are associated with at least one of Leaf Nodes 730A-730N. While Root Node 710 and Intermediate Nodes 720A-720H are optionally associated with predefined rules, generated allocation rules, and/or business objects, those business objects, with which Root Node 710 and Intermediate Nodes 720A-720H are associated, are not necessarily configured to receive transaction allocations. For example, in the illustrated example, Intermediate Note 720B is associated with an Eastern sales division. Because the Eastern sales division is an organizational business object and not an individual person it may not be configured to receive some types of transaction allocations (e.g. a commission). Root Node 710 and Intermediate Nodes 720A-720H each optionally have at least one daughter node that is a leaf node 730A-730N. This daughter node may be associated with a manager of the business object associated with its parent node. For example, Leaf Node 730C, a daughter node of Intermediate Node 720B, may be associated with an Eastern sales division manager.
In the above case, the business object associated with Leaf Node 730C has a “management” role with respect to Intermediate Node 720B. In alternative embodiments, this management role is held by a business object associated with a node other than an immediate daughter node. For example, the business object associated with Leaf Node 730G may have a management role with respect to the business objects associated with both Intermediate Nodes 720D and 720F. The management role with respect to the business object associated with Intermediate Node 720H is illustrated by a Dotted Line 740.
In some embodiments, Root Node 710 and/or specific members of Intermediate Nodes 720A-720H are associated with a predefined rule but not with a business object. In some embodiments, Root Node 710 and/or specific members of Intermediate Nodes 720A-720H are associated with a predefined rule and a business object that is not configured to receive a transaction allocation. This business object may be, for example, a product classification. Members of Intermediate Nodes 720A-720H having different types of associations can be found in a single instance of Hierarchical Data Structure 700.
In embodiments of the invention illustrated by FIG. 7, transactions are allocated by executing queries based on the generated allocation rules associated with Leaf Nodes 730A-730N. In these embodiments, it is not necessary to execute queries based on any generated allocation rules associated with Root Node 710 or Intermediate Nodes 720A-720H in order to allocate transactions. However, as is shown further herein, these generated allocation rules are optionally used for processing of transactions that are unallocated, under-allocated or over-allocated, using the allocation rules associated with Leaf Nodes 730A-730N alone.
In various embodiments of the invention, a first attempt at allocating a set of transactions is made using generated allocation rules associated with leaf nodes, such as Leaf Nodes 730A-730L. This process is similar to that discussed with respect to FIG. 5, except that the queries executed in Execute Queries Step 540 are based on generated allocation rules associated with leaf nodes and those transactions not selected by any query are identified. After Execute Queries Step 540, any transactions not completely allocated are optionally identified.
In a second attempt at transaction allocation, the identified (unallocated, under-allocated, or over-allocated) transactions are queried using queries based on generated allocation rules associated with root or intermediate nodes, such as Root Node 170 and/or Intermediate Nodes 720A-720H. In some embodiments, the generated allocation rule associated with Root Node 710 is configured to select all possible transactions. Thus, in these embodiments, all transactions not selected on the first allocation attempt are selected on the second allocation attempt by at least one query. Results of the second allocation attempt are used to determine, through additional steps, allocation of the identified transactions to business objects.
FIG. 8 illustrates an example of an allocation method used to allocate transactions according to various embodiments of the invention. In these embodiments, several attempts are made to allocate transactions and the additional attempts are configured to allocate transactions that were unallocated, under-allocated or over-allocated in a first attempt. The method of FIG. 8 includes using Hierarchical Data Structure 700 to allocate transactions that were unallocated, over-allocated or under-allocated transactions in a previous attempt at allocation. In an Access Leaf Rules Step 810, generated allocation rules stored in Rule Data 150 and associated with Leaf Nodes 720A-720H are accessed using Query Engine 170. Leaf Nodes 720A-720H are associated with business objects configured to receive transaction allocations. In some embodiments, Access Leaf Rules Step 810 is analogous to Access Rules Step 530 (FIG. 5) except that only generated allocation rules associated with business objects configured to receive transaction allocations are accessed.
In an Execute Leaf Queries Step 820, the generated allocation rules accessed in Access Leaf Rules Step 810 are used to execute queries on Transaction Data 155. In some embodiments, Execute Leaf Queries Step 820 is analogous to Execute Queries Step 540. As in Execute Queries Step 540, the executed queries are typically generated using the accessed allocation rules.
In an Identify Unallocated Transactions Step 830, those transactions not selected in any of the queries executed in Execute Leaf Queries Step 820 are identified. These transactions are considered unallocated. In some embodiments, the unallocated transactions are identified by setting an attribute associated with each of the transactions that are allocated. For example, in one embodiment, each of a set of data records includes a “selected” flag and a pointer to an associated transaction. When a transaction is selected by a query this flag is set. In Identify Unallocated Transactions Step 830 these records are searched and unallocated transactions are identified.
In an optional Identify Under-allocated Transactions Step 840, transactions that are not completely allocated are identified. For example, if a transaction includes a 10% commission on a sale and Execute Leaf Queries Step 820 results in identification of business objects configured to receive 8% of the sale, 2% of the sale amount is unallocated. Identify Under-allocated Transactions Step 840 typically includes comparing a value of a transaction available to be allocated with a sum of values that could be allocated to business objects identified in Execute Leaf Queries Step 820. In various embodiments, the “value” of a transaction is measured in dollars, percentage of another transaction, amount of a commodity, amount of time, amount of another resource, or the like.
In an optional Identify Over-allocated Transactions Step 850, transactions that are over-allocated are identified. For example, if a transaction includes a 10% commission on a sale and Execute Leaf Queries Step 820 identifies six business objects, each configured to receive 2% of the sale, then 2% of the sale amount is over-allocated. As in Identify Under-allocated Transaction Step 840, Identify Over-allocated Transactions Step 850 typically includes comparing a value of a transaction available to be allocated with a sum of values that could be allocated to business objects identified in Execute Leaf Queries Step 820.
In an Allocation Plan Complete Step 860, Allocation Manager 190 is used to examine the results of Identify Unallocated Transactions Step 830, Identify Under-allocated Transactions Step 840 and/or Identify Over-allocated Transactions Step 850. If no transactions have been identified as being unallocated, under-allocated or over-allocated in the allocation plan then the allocation plan is complete and the process can continue to an optional Allocate Step 865 wherein actual allocation occurs, as discussed further herein. If there are unallocated, under-allocated or over-allocated transactions then the method continues to an Access Non-Leaf Rules Step 870.
In Access Non-Leaf Rules Step 870, Allocation Manager 190 is used to access generated allocation rules associated with Root Node 710 and Intermediate nodes 720A-720H. In some embodiments, this step is analogous to Access Leaf Rules Step 810 except that the accessed generated allocation rules are not necessarily associated with business objects configure to receive transaction allocations.
In an Execute Non-Leaf Queries Step 880, the generated allocation rules accessed in Access Non-Leaf Rules Step 870 and Query Engine 170 are used to execute queries on the transactions identified as being unallocated, under-allocated and/or over-allocated in Steps 830, 840, and 850, respectively. In some embodiments, one of the generated allocation rules used in Execute Non-Leaf Queries Step 880 is configured to select all possible transactions, thus ensuring that all transactions will be selected by at least one query in Execute Non-Leaf Queries Step 880.
In an Identify Managing Business Objects Step 890, Allocation Manager 190 is used to identify a person, or persons having a role of manually determining the allocation of the transactions selected using each query in Execute Non-Leaf Queries Step 880. The identification of this person is dependent on the generated allocation rule on which the query was based and the business object associated with that generated allocation rule. For example, in some embodiments, several unallocated transactions are selected using the generated allocation rule associated with Intermediate Node 720D. Intermediate Node 720 is associated with a person (business object) having a “manager” role and authorized to manually determine the allocation of these transactions. The person having a manager role is optionally also associated with a member of Leaf Nodes 730A-730N, such as Leaf Node 730G. In some cases, more than one person having a manager role will be identified for a particular transaction. Identify Managing Business Objects Step 890 is performed for each query executed in Execute non-Leaf Queries Step 880.
In a Manual Selection Step 895, the allocation of transactions queried in Execute Non-Leaf Queries Step 880 are manually determined by the business objects (e.g. person or persons) identified in Identify Managing Business Objects Step 890. For example, in some embodiments, a person associated with Intermediate Node 720H receives a request to manually determine an allocation plan for unallocated transactions. She receives this request because the transactions were selected using the generated allocation rule associated with Intermediate Node 720H. In some of these embodiments, the person associated with Intermediate Node 720H is not configured to receive an allocation herself, in other embodiments she is also associated with a member of Leaf Nodes 730A-730N, such as Leaf Nodes 730L or 730M, and thus is configured to receive allocations. In one embodiment, this person receives a task assigning her responsibility to manually plan the allocation of the transactions. The allocation task is optionally facilitated by a graphical user interface showing: a partial allocation, why the person was chosen, business objects associated with daughter nodes of Intermediate Node 720H, options (such as an HTML based form) configured for manually completing the allocations, allocations to business object associated with Leaf Nodes 730A-730N that have already been planned for a particular transaction, and/or the like. In Manual Selection Step 895, the determinations made by the business objects identified in Identify Managing Business Objects Step 890 are typically configured to complete the allocation plans of the transactions queried in Execute Non-Leaf Queries Step 880.
Following Manual Selection Step 895, the method proceeds to Allocate Step 865 wherein the transactions are allocated to the business objects specified in steps 820 and 895.
Several embodiments are specifically illustrated and/or described herein. However, it will be appreciated that modifications and variations are covered by the above teachings and within the scope of the appended claims without departing from the spirit and intended scope thereof. For example, the various computer systems described herein are optionally implemented as distributed systems; likewise the location of specific data records is optionally varied among a variety of alternative locations. Communication between various elements of the invention may occur over the World Wide Web or other computer network. The invention is optionally implemented as an internet application.
The invention is optionally adapted to alternative types of ordered data structures that allow inheritance between nodes. In addition, in some embodiments, business objects configured to receive an allocation and business objects having management roles need not be classified by the type of node with which they are associated. In alternative embodiments, alternative methods of identification are used. For example, in one embodiment, a role attribute may be used to distinguish business objects configured to receive allocations and/or to have a manager role. In this embodiment, the role attribute is used to determine which rules are accessed in steps 810 and 870. In some embodiments, a generated allocation rule can be empty (e.g., no allocation rule is inherited or predefined) and, in some embodiments, the systems and methods of the invention are used to update existing allocation rules. In some embodiments, a generated allocation rule is determined by traversing hierarchical Data Structure 200 from a leaf node, to an intermediate node, and then to the root node. In these embodiments, the generated allocation rule is generated by collecting predefined rules associated with traversed nodes. Embodiments of the invention include computer code stored on a computer readable medium and configured to execute methods of the invention.
In this application “allocation rules” are meant to include both rules used to select a business object to receive an allocation resulting from a transaction and rules used to calculate the amount of the allocation. In some embodiments, an allocation of all or part of a transaction to a business object is treated as a new transaction. For example, the payment of a commission, once determined, is optionally managed as a new transaction.

## Claims

1. A transaction allocation system, comprising:
a processor; and
memory storing instructions that, when executed by the processor, cause the processor to:
access a first allocation rule associated with one of a plurality of business objects represented by a hierarchical data structure;
execute a first query on transaction data using a query engine, the first query being based on the first allocation rule, the transaction data characterizing one or more transactions;
access a second allocation rule associated with another of the plurality of business objects represented by the hierarchical data structure; and
execute a second query on a subset of the transaction data using the query engine, the second query being based on the second allocation rule and identifying a business object for determining allocation of at least one of the one or more transactions; and

generate transaction allocation output based on results of the first and second queries.

2. A transaction allocation system according to claim 1, wherein the first query based on an allocation rule is generated using the hierarchical data structure and associated with a leaf node of the hierarchical data structure, the first query generating a first set of transactions, at least one transaction of the first set of transactions including a transaction value, a second set of transactions having an allocation determined by a business object identified using the second query, at least one transaction of the second set of transactions including a transaction value, the instructions when executed by the processor further causing the processor to:
generate a summation of the transaction values as part of the transaction allocation output.

3. A transaction allocation system according to claim 1, wherein the transaction allocation output includes digital data transferred through a communications channel between a computing system and a client.

4. A transaction allocation system according to claim 1, wherein the second query is generated using the hierarchical data structure.

5. A transaction allocation system according to claim 1, wherein the generated allocation rule includes a predefined rule associated with a node of the hierarchical data structure.

6. A method of determining allocation of one or more transactions, the method comprising:
accessing a first allocation rule associated with one of a plurality of business objects represented by a hierarchical data structure;
executing a first query on transaction data using a query engine, the first query being based on the first allocation rule, the transaction data characterizing the one or more transactions;
accessing a second allocation rule associated with another of the plurality of business objects represented by the hierarchical data structure;
executing a second query on a subset of the transaction data using the query engine, the second query being based on the second allocation rule and identifying a business object for determining allocation of at least one of the one or more transactions; and
generating transaction allocation output based on results of the first and second queries.

7. A method according to claim 6, wherein the business object determines allocation manually.

8. A method according to claim 6, further including receiving the transaction data characterizing the one or more transactions from a transaction source.

9. A method according to claim 6, further including allocating the one or more transactions responsive to the results of the queries.

10. A method according to claim 6, wherein a subset of the transaction data is representative of a subset of the one or more transactions.

11. A method according to claim 6, wherein a subset of the transaction data is representative of a subset of the one or more transactions, and the subset of the one or more transactions includes an under-allocated transaction.

12. A method according to claim 6, wherein a subset of the transaction data is representative of a subset of the one or more transactions, and the subset of the one or more transactions includes an unallocated transaction.

13. A method according to claim 6, wherein a subset of the transaction data is representative of a subset of the one or more transactions, and the subset of the one or more transactions includes an over-allocated transaction.

14. A method according to claim 6, further comprising:
determining transaction allocation of any of the one or more transactions that are unallocated, under-allocated, or over-allocated;
parsing each of the one or more transactions to determine a value of each of the one or more transactions;
summing the values determined by parsing each of the one or more transactions; and
including the sum of the determined values in the transaction allocation output.

15. The method of claim 14, wherein the one or more transactions include at least one of a sales commission, a purchase cost, an inventory allocation, and a resource allocation.

16. The method of claim 14, wherein determining transaction allocation of any of the one or more transactions that are unallocated, under-allocated, or over-allocated, is determining transaction allocation of an unallocated transaction.

17. The method of claim 14, wherein determining transaction allocation of any of the one or more transactions that are unallocated, under-allocated, or over-allocated, is determining transaction allocation of an under-allocated transaction.

18. A system for determining allocation of a plurality of transactions, the system comprising:
means for accessing a first allocation rule associated with one of a plurality of business objects represented by a hierarchical data structure;
means for executing a first query on transaction data using a query engine, the first query being based on the first allocation rule, the transaction data characterizing the one or more transactions;
means for accessing a second allocation rule associated with another of the plurality of business objects represented by the hierarchical data structure;
means for executing a second query on a subset of the transaction data using the query engine, the second query being based on the second allocation rule and identifying a business object for determining allocation of at least one of the one or more transactions; and
means for generating transaction allocation output based on results of the first and second queries.

19. A computer readable medium storing processor-executable instructions for determining an allocation plan, comprising:
program code for accessing a first allocation rule associated with one of a plurality of business objects represented by a hierarchical data structure;
program code for executing a first query on transaction data using a query engine, the first query being based on the first allocation rule, the transaction data characterizing the one or more transactions;
program code for accessing a second allocation rule associated with another of the plurality of business objects represented by the hierarchical data structure;
program code for executing a second query on a subset of the transaction data using the query engine, the second query being based on the second allocation rule and identifying a business object for determining allocation of at least one of the one or more transactions; and
program code for generating transaction allocation output based on results of the first and second queries.