Patent Publication Number: US-2023161955-A1

Title: Database model which provides management of custom fields and methods and apparatus therfor

Description:
BACKGROUND 
     The use of databases to track activity is well known. For example, spreadsheets and other databases have been used for many years to keep track of the status of projects, and specific tasks within the project. More recently, specific software programs and services, referred to as project management or work tracking “tools” herein, have been provided which are focused on project management. Examples of such products and services are ASANA™, SMARTSHEET™, TRELLO™ and WRIKE™. 
     Each of these tools provides the ability for a user to customize behavior of the tool, to some extent, to fit the specific needs of a user. For example, users may have the need to track different types of data and the need to describe the different data in a way the user can understand. Typically, the tools define projects that have various specific tasks. The tasks are described by field values. Each field may have specific characteristics specified by it data type data type. 
     For example, one user might want to manage the status of orders and product inventory and another user might be managing the development cycle of a software application. As a result, each tool allows the user to create custom data field names (also referred to as “labels” and “descriptors”) such as “Location”, “Quantity”, “Time”, “Release Date” or any other descriptive label that the user may wish to use. This labeling is rudimentary and very similar to labeling columns in a spreadsheet. 
     However, project management tools are often used as collaborative tools by a large group of users, such as employees of an organization. The organization may have many projects to manage, each project having many tasks and users. Various users may participate in various projects within the organization. Further, each project may have different characteristics. Therefore, each project may have different data fields and related descriptors. For example, the chart below shows an extremely simple example of data fields for three different projects within an organization. 
     
       
         
           
               
               
               
             
               
                   
               
               
                 Project A 
                 Project B 
                 Project C 
               
               
                   
               
             
            
               
                 DUE DATE 
                 DUE DATE 
                 DUE DATE 
               
               
                 QUANTITY 
                 LOCATION 
                 VERSION 
               
               
                 PRICE 
                 VEHICLE TYPE 
                 STATUS 
               
               
                 DELIVERY 
                 CUSTOMER 
                 DEVELOPER 
               
               
                 RESPONSIBLE PARTY 
                   
                 RESPONSIBLE PARTY 
               
               
                   
               
            
           
         
       
     
     In the example above, the data field DUE DATE is used by all three projects, and the data field RESPONSIBLE PARTY is used by Project A and C, but not Project B. Also, each project has data fields that are unique from other projects. Further, as noted above, each project can have various users. The number of data fields required for a specific project can be very high and the resulting number of custom data fields across an organization can be even larger, sometimes in the thousands. 
     Of course, it is desirable to manage the use of custom data fields. For example, if one user creates accustom field for one project, it is desirable to allow other users to use that field in other projects. Conversely, if a field with the label and specific characteristics is created, it can be problematic if a different field is created with the same label and used in a different context. For example, some tool permit users to share custom fields across projects, but they don&#39;t have to be unique. Thus, two fields having very different characteristics can both be named “Priority”. For example, one field can be a dropdown list having selections “1”, “2”, or “3” indicating levels of priority and another field can be a checkbox indicating whether or not the task associated with the field is a priority. Other tools allow users to create custom data fields whereby users can have multiple data fields having the same name that have similar or different characteristics. When a user creates a data field, it is distinct from other data fields that may have the same name. On the other hand, a user can edit a data field created by another user. For example, a user may wish to delete a drop option in a data field or otherwise modify the data field. These models for customizing data fields can lead to confusion, inaccuracy, and inefficiency in project management. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWING 
       The invention will be described through embodiments and the attached drawing in which: 
         FIG.  1    is an example of a user interface displaying a task list; 
         FIG.  2    is an example of a user interface displaying a task detail; 
         FIG.  3    is a block diagram of a task object, a custom property proto object and a custom property number value object; 
         FIG.  4    is a block diagram of project objects, a custom property proto object and custom property project settings objects; 
         FIG.  5    is a block diagram of a task object, a custom property proto object and a custom property options objects; 
         FIG.  6    is a flowchart of a method for changing or adding custom filed objects; 
         FIG.  7    is a user interface displaying a disabled filed indicator; 
         FIG.  8    is a flowchart of a method for identifying orphaned values; 
         FIG.  9    is a flowchart of a method for ordering tasks in a task display; 
         FIG.  10    is a user interface displaying a deleted dropdown menu value; and 
         FIG.  11    is a computer architecture of a project management system. 
     
    
    
     DETAILED DESCRIPTION 
     While devices, methods, apparatuses, and computer-readable media are described herein by way of examples and embodiments, those skilled in the art recognize that devices, methods, apparatuses, and computer-readable media are not limited to the embodiments or drawings described. Rather, the intention is to cover all modifications, equivalents and alternatives falling within the spirit and scope of the appended claims. Any headings used herein are for organizational purposes only and are not meant to limit the scope of the description or the claims. As used herein, the word “may” is used in a permissive sense (i.e., meaning having the potential to) rather than the mandatory sense (i.e., meaning must). Similarly, the words “include,” “including,” and “includes” mean including, but not limited to. 
     The applicant has developed a data model for managing custom fields in a project management tool whereby custom fields can be defined and shared across an organization, and are always unique. If one employee creates a field for ‘Priority’, anyone else in the organization can use that field on their projects. There can&#39;t be more than one ‘Priority’ field within the organization and the attributes of the field will be preserved across projects. Custom fields can be displayed or hidden at the project list level. The data model allows users to choose to show or hide each field on a project. Further, the data model allows advanced search functions for custom fields and allows for reporting across projects. For example, a user can search across multiple projects for all tasks where the field ‘Priority’ is set to ‘High’. As another example, for numeric fields, a report can be generated across projects for specific ranges of numbers. The embodiment can also perform basic aggregations of number fields on tasks. If a user multi-selects 5 tasks, then the number field is summed or charts or other aggregations of the data care created. This works across projects and search reports. 
     Other field level unique features can be enabled such as unique colors for custom field drop-downs. For example, for the custom field ‘Priority’, a value of ‘High’ can be colored red, a value of ‘Medium’ can be colored yellow and a value of ‘Low’ can be colored green. Such unique features can persist across projects and various views, such as list views and calendar views. Custom fields can be aggregated with multiple projects. For example, if a task is in three projects, and each has custom fields, then the task has all those custom fields with consistent ordering. Because custom fields are shared across an organization and are unique, if a custom field is in multiple of these projects then it only appears once in the task. Also, the data model makes custom fields resistant to “field trampling”—if a user changes another user&#39;s custom field, or a task is removed from projects, then the custom field data still exists on the task in a read-only manner. A user can simply reverse these actions to make the field data editable once more. In the novel data model, custom fields can be first-class fields in the API to allow other parties to build integrations that leverage the custom fields. 
     The disclosed embodiment is achieved through a novel data model in which an independent object is used to represent each custom field (sometimes referred to as a custom “property” herein). The embodiment associates fields with tasks that are part of a project. For each custom field associated with a task, a unique object is created that associates the task with a value for that custom field. This is referred to as a “join object” approach. To aid understanding of the technical advantages resulting from the data model, a very brief description of the user experience is presented immediately below, followed by a more detailed description of the data model. 
     Custom fields allow users of a project management tool to track work across whatever information is most useful for them. If field names, descriptions, and values are customizable by a user, the user can create a field for anything of interest to the users of a project. The embodiment permits users to create custom fields for just about any data that they want to track in a structured way. The custom fields are then unique and available across a group of users, tasks and projects. 
     For example,  FIG.  1    is a user interface, such as an interactive display on the screen of a computing device, illustrating custom fields for tasks in a project. User interface  100  includes 5 columns, Task Column  110 , Stage Column  120 , Priority Column  130 , Time Required Column  140  and Due Date Column  150 . In this example, Task column  110  and Due Date column  150  each define “out of the box” fields that are hardcoded into the software tool. However, Stage Column  120 , Priority Column  130 , and Time Required Column  140  define custom fields that were created by a user of the software tool. For each task, fields are defined for associated custom fields. For example, the task “Missing screen shot on product page” has a custom field of “Stage” having a value of “Phase 1”. Note that not all tasks in a project will necessarily be associated with any specific custom filed of that project. For example, in  FIG.  1   , the task “Product update blog post” is not associated with the custom field “Stage” or the custom field “Time Required”. As shown in  FIG.  1   , these fields can have null values for such unassociated tasks. 
     Custom fields added to a project can appear in a list view of that project, as shown in  FIG.  1   , or in the task details of any task. The data model allows fields to be managed at the project level and shown on all tasks in that project. A field created for one project is available to all other projects within the organization.  FIG.  2    is a user interface displaying the details of the task “Broken links in help page” of  FIG.  1   . As an example, the interface of  FIG.  2    can be produced by selecting the task form the list of  FIG.  1   . User interface  200  displays the task at  210 , a description of the task at  212  and the values of all custom fields associated with the task at  260 . 
     Turning to the data model, Custom Fields of the embodiment can be divided into two kinds: primitives (like strings, integers, etc. . . . ) and references (other objects in the system). All primitive and reference values are modeled as unique independent objects that associate the task with the value. Additionally, the cardinality of properties may be either scalar (single value) or list (multiple values). For example:
         A “tracking number” field would use a primitive scalar property (single string value)   A “categories” field would use a primitive list property (multiple enum values)   An “owner” field would use a reference scalar property (single user value)   A “dependencies” field would use a reference list property (multiple task values)       

     As noted above, tasks in a project can hold user-specified custom fields which provide extra information; for example, a priority value or a number representing the time required to complete a task. This lets a user define the type of information that each task within a project can contain. A custom field is defined by metadata. This metadata is shared across an entire organization or workspace. Projects can have custom fields associated with them individually. This is conceptually akin to adding columns in a database or a spreadsheet: every task (row) in the project (table) can contain information for that field, including “blank” values, i.e. null data. Tasks have custom field values assigned to them. 
     The invention includes a novel schema. Objects, metadata, and classes are the basic components that are used to build object definitions in the schema. Objects are structures that define the property at the highest level. Attributes, sometimes referred to as “metadata” herein define the information that is stored in an object or in another attribute. As an example, an organization has defined a custom field for “Priority”. This field is of enum type (described below and sometimes referred to as “option” type) and can have user-defined values of Low, Medium, or High. This is the custom field metadata, and it is visible within, and shared across, the entire organization. A project can then be created in the organization, called “Bugs”, and the “Priority” custom field can be associated with that project. This will allow all tasks within the “Bugs” project to have an associated “Priority”. When a new task is created within “Bugs”, the new task will have a field named “Priority” which can take on the custom field value of one of, Low, Medium, or High. 
     An object definition is an association of attributes that describe the characteristics of an object that stores specific pieces of data. The kind of data that the object stores determines which attributes are needed to define the object. Defining objects and attributes this way gives the schema the ability to efficiently define many different types of objects. Object definitions are categorized into groups that are called classes. Classes act as blueprints that can be used each time a new object is created. When a new object is created, the object&#39;s class determines the attributes that are associated with the new object, including which attributes are required and which attributes are optional. 
     The objects of the data model are constructed in accordance with the following schema. In the embodiment, the suffix “Proto” is used to denote prototypes (definitions) of custom fields, and the suffix “Value” is used for actual instances of the values. The primary objects of the data model are described briefly immediately below. 
     “Proto”: Stores the metadata about a custom filed. Each different type of custom field has its own subclass of the generic Proto. For example, CustomPropertyNumberProto’ is subclassed from ‘CustomPropertyAbstractProto’, and adds properties that are specific to representing the numeric type in a custom field. 
     “Value”: An instance of a value of a custom field as it appears on a task (or eventually, other objects in the system that can have custom field values). This is represented as the join between a Proto and the object the custom field is set on. Part of the data in this join is the actual value the custom field takes on. Like Protos, Values are also subclassed based on the type of custom property. 
     “ProjectSetting”: The join between a Proto and a Project that bestows that Proto upon all of its tasks. There may also be settings specific to the Project, such as whether the custom field should appear in the task list by default, and metadata to determine the ordering of the field in the Project. 
     “TaskChangedStory”: Stores the metadata about a Value changing on a task. Each different type of custom property has its own subclass of the generic TaskChangedStory. For example, ‘TaskCustomPropertyNumberChangedStory’ is subclassed from 
     ‘TaskCustomPropertyAbstractChangedStory’ and contains properties for the old/new data specific to the numeric type. Each subtype should contain two properties: old_dataname, new_dataname, where dataname is the custom field name for data in the Value object. 
     “ProtoSubmission”: Stores information on create and edit submissions for custom field protos. Keeps track of the submission status (pending, success, or failure) to keep the edit/create field dialog open on the client until changes propagate. The successful ProtoSubmissions associated with a given proto represents the change history for that proto. All custom field types use the same ProtoSubmission class. 
     Each Custom Field object of the embodiment has the following fields: 
     
       
         
           
               
               
             
               
                   
               
               
                 Field 
                 Description 
               
               
                   
               
             
            
               
                 id 
                 1234. Globally unique ID of the custom field. 
               
               
                 created_at 
                 ‘2012-02-22T02:06:58.147Z’. The time at which 
               
               
                   
                 this custom field was created. 
               
               
                 name 
                 ‘Priority’. The name of the custom field. 
               
               
                 type 
                 ‘text’‘enum’‘number’. The type of the custom field. 
               
               
                   
                 Must be one of the given values. 
               
               
                 enum_options 
                 [{id: 789, name: ‘Low’, enabled: ‘true’, color: 
               
               
                   
                 ‘blue’}, . . .]. Only relevant for custom fields of 
               
               
                   
                 type ‘Enum’. This is described in more detail 
               
               
                   
                 below. 
               
               
                 precision 
                 Only relevant for custom fields of type ‘Number’. 
               
               
                   
                 This field dictates the number of places after the 
               
               
                   
                 decimal to round to, i.e. 0 is integer values, 1 
               
               
                   
                 rounds to the nearest tenth, and so on. 
               
               
                   
               
            
           
         
       
     
     For each custom field associated with a task, an object is created that associates the task with a value for that custom field. There is a new type of object for each type of property, e.g.,CustomPropertyTextValue, CustomPropertyEnumValue, CustomPropertyReferenceValue, “CustomPropertyNumberValue” etc. . . . “Object” refers to the object the property is set on, “property” refers to the CustomPropertyAbstractProto the value is set for and “value’ refers to the actual value of the property. As an alternative to the model described herein in detail, for each property set on a Task, there can be a row in the database just like a normal property (object_id, property_id, value, etc.). For scalars these would automatically be sent from server to client for any projection on an object. Given a projection, a primitive property by ID is set. As another alternative, Join Objects can be used for reference properties, and Property Rows for primitive properties. As yet another alternative, Join objects can be used for reference properties, and a JSON Blob for primitive properties. As illustrated in  FIG.  3   , a custom property value object  310  assigns a value for a particular proto  320  to a task. In this example, the CustomPropertyNumberValue object assigns the value “1” for “Number of Reports” to the task  330  “Cannot Login.” 
     As illustrated in  FIG.  4   , a single custom field (“proto”) can be associated with multiple projects. CustomPropertySetting objects  440  associate a proto to a project. In this example, the CustomPropertyNumberProto “Number of Reports” object  420  is associated with both the Project “Android Bugs” object  450  and the Project “iOS Bugs” object  450  through respective CustomPropertySetting objects  440 . 
     Since custom fields can be defined for many types, and these types have different data and behaviors, there can be fields that are relevant to a particular type but not relevant to other types. For instance, the enum_options object noted above is only relevant for the enum type and defines the set of choices that the enum object could represent. As illustrated in  FIG.  5   , EnumProto object  520  has multiple options, represented as EnumOption objects  550 , in this example EnumOption objects named P1, P2, and P3. These objects have a name and proto reference, along with other metadata (rank for ordering, color for display . . . ). EnumValue object  510 , object  123  in this example, associates a particular option to task object  530 . In this example option 11 of P2 is associated with the task “Cannot Login”. This model allows for dynamic renaming options. 
     In the embodiment, custom fields are of one of three types; text, number, and enum. Number fields can have an arbitrary precision associated therewith. For example, a precision of 2 would round its value to the second (hundredths) place, i.e., 1.2345 would round to 1.23. On tasks, the custom field value will have a number_value property to represent this field. Enum fields represent a selection from a list of options. On the metadata, they will contain all the options in an array. Each option has 4 properties:
         id—the id of this enum option. Note that this is the id of the option—the Custom Field itself has a separate id.   name—the name of the option, e.g. “Choice #1”   enabled—whether this field is enabled. Disabled fields are not available to choose from when disabled, and are visually hidden in the Asana application, but they remain in the metadata for Custom Field values which were set to the option before the option was disabled.   color—a color associated with this choice.       

     On the task&#39;s custom field value, the enum will have an enum_value property which will be the same as one of the choices from the list defined in the custom field metadata. 
     Custom fields can be accessible via an API through several endpoints at the top level (e.g. /custom_fields and /custom_field_settings) and through calls on workspaces, projects, and tasks resources. The API also provides a way to fetch both the metadata and data which define each custom field, so that a client application may render the proper UI, such as those shown in  FIGS.  1  and  2   , to display or edit the values. Example API calls are set forth below. 
     Get the metadata for a custom field of type ‘text’ 
     
       
         
           
               
               
             
               
                   
                   
               
             
            
               
                   
                 # Request 
               
               
                   
                 curl -H “Authorization: Bearer &lt;personal_access_token&gt;” \ 
               
               
                   
                 https://app.asana.com/api/1.0/custom_fields/124578 
               
               
                   
                 # Response 
               
               
                   
                 HTTP/1.1 200 
               
               
                   
                 { 
               
               
                   
                  “data”: [ 
               
               
                   
                   { 
               
               
                   
                    “id”: 134679, 
               
               
                   
                     “created_at”: “2016-07-11T14:29:23.249Z”, 
               
               
                   
                     “name”: “Owner”, 
               
               
                   
                     “type”: “text” 
               
               
                   
                     } 
               
               
                   
                    ] 
               
               
                   
                   } 
               
               
                   
                   
               
            
           
         
       
     
     Get the metadata for a custom field of type ‘number’ 
     
       
         
           
               
               
             
               
                   
                   
               
             
            
               
                   
                 # Request 
               
               
                   
                 curl -H “Authorization: Bearer &lt;personal_access_token&gt;” \ 
               
               
                   
                 https://app.asana.com/api/1.0/custom_fields/124578 
               
               
                   
                 # Response 
               
               
                   
                 HTTP/1.1 200 
               
               
                   
                  { 
               
               
                   
                   “data”: [ 
               
               
                   
                    { 
               
               
                   
                       “id”: 938271, 
               
               
                   
                       “created_at”: “2016-07-11T14:29:23.249Z”, 
               
               
                   
                       “name”: “Price”, 
               
               
                   
                       “type”: “number”, 
               
               
                   
                       “precision”: 2 
               
               
                   
                      } 
               
               
                   
                     ] 
               
               
                   
                    } 
               
               
                   
                   
               
            
           
         
       
     
     Get the metadata for a custom field when that field is of type ‘enum’. 
     
       
         
           
               
               
             
               
                   
                   
               
             
            
               
                   
                 # Request 
               
               
                   
                 curl -H “Authorization: Bearer &lt;personal_access_token&gt;” \ 
               
               
                   
                  https://app.asana.com/api/1.0/custom_fields/124578 
               
               
                   
                  # Response 
               
               
                   
                  HTTP/1.1 200 
               
               
                   
                  { 
               
               
                   
                   “data”: [ 
               
               
                   
                    { 
               
               
                   
                     “id”: 124578, 
               
               
                   
                     “created_at”: “2016-07-11T14:29:23.249Z”, 
               
               
                   
                     “name”: “Priority”, 
               
               
                   
                     “type”: “enum”, 
               
               
                   
                     “enum_options”: [ 
               
               
                   
                      { 
               
               
                   
                       “id”: 789, 
               
               
                   
                       “name”: “Low”, 
               
               
                   
                       “enabled”: true, 
               
               
                   
                       “color”: “blue” 
               
               
                   
                      }, 
               
               
                   
                      { 
               
               
                   
                       “id”: 208, 
               
               
                   
                       “name”: “Medium”, 
               
               
                   
                       “enabled”: false, 
               
               
                   
                       “color”: “yellow” 
               
               
                   
                      }, 
               
               
                   
                      { 
               
               
                   
                       “id”: 439, 
               
               
                   
                       “name”: “High”, 
               
               
                   
                       “enabled”: true, 
               
               
                   
                       “color”: “red” 
               
               
                   
                      } 
               
               
                   
                     ] 
               
               
                   
                    } 
               
               
                   
                   ] 
               
               
                   
                  } 
               
               
                   
                   
               
            
           
         
       
     
     Return a List of All Custom Fields in a Workspace 
     As custom fields are shared across a workspace or organization, the workspace can be queried for its list of defined custom fields. Like other collection queries, the fields can be returned as a compact record. The compact record for custom fields can include type as well as id and name. 
     
       
         
           
               
               
             
               
                   
                   
               
             
            
               
                   
                 # Request 
               
               
                   
                 curl -H “Authorization: Bearer &lt;personal_access_token&gt;” \ 
               
               
                   
                 https://app.asana.com/api/1.0/workspaces/14916/custom_fields 
               
               
                   
                 # Response 
               
               
                   
                 HTTP/1.1 200 
               
               
                   
                 { 
               
               
                   
                  “data”: [ 
               
               
                   
                    { 
               
               
                   
                     “id”: 124578, 
               
               
                   
                     “name”: “Priority”, 
               
               
                   
                     “type”: “enum” 
               
               
                   
                    }, 
               
               
                   
                    { 
               
               
                   
                     “id”: 134679, 
               
               
                   
                     “name”: “Owner”, 
               
               
                   
                     “type”: “text” 
               
               
                   
                    }, 
               
               
                   
                    “~...” 
               
               
                   
                   ] 
               
               
                   
                  } 
               
               
                   
                   
               
            
           
         
       
     
     The returned information can describe the custom field metadata—the field&#39;s name, its type, and any additional information about the custom field as is appropriate. 
     As noted above, custom fields are associated with one or more projects. A mapping between a custom field and a Project is handled with a CustomPropertyProject Setting object as discussed above with respect to  FIG.  4   . This object can contain a reference for each of the custom field and the Project, as well as additional information about the per-Project status of that particular custom field. For example, the metadata is_important can specify if the custom field will appear in the task list of  FIG.  1   . A Project can also be modified to add a custom field with endpoints. For example, /projects/addCustomFieldSettings and projects/removeCustomFieldSettings can be used to associate and dissociate the custom field and Project. The top-level id of each entry in the custom_fields array is the id of the custom field metadata, as it is the compact representation of this metadata. This can be used to refer to the full metadata by making a request to the /custom_fields/{custom_fields id} endpoint as described above. 
     The data model allows the validation of custom filed names across projects when creating or editing custom fields. A custom field name should not be identical to other custom fields in the organization or any reserved names. For example, assume that a user creating a new custom filed want to name the field “Priority.” As the user enters the letters “p”, “r”, “i’ . . . , the user interface will display all custom filed names having that sequence of letters and allow the user to select one of those existing custom fields or edit the names to create a new custom field. Semantic analysis and AI can be used to flag or prevent semantically similar custom fields. 
     The novel data model described herein, which allows custom fields to be shared across projects results in better operation of a computing system executing project management operations. However, the model also raises some technical issues that need to be dealt with. Resolutions to those issues are described below. 
     As shown in  FIG.  7   , when information that is contained in a custom field value loses a logical association with its metadata definition, the value becomes disabled. For example, if the custom field metadata is removed from a Project, or a Task with a custom field is moved to a different Project which does not have the custom field metadata associated with it, a logical association can be lost. In the embodiment, the value remains on the Task, and the custom field metadata can still be found and examined. Moving the Task back under a Project with that Custom Field applied to it or applying the custom field metadata to the current Project will return the Custom Field value to an enabled state. In this scenario, the Custom Field will be re-enabled and editable again. Tasks that are associated with multiple Projects do not become disabled, so long as at least one of the Projects is still associated with the custom field metadata. In other words, Tasks with multiple Projects will retain logically associated to the set of custom field metadata represented by all of their Projects. The API can enforce the same operations on disabled custom field values as on enabled values. 
     Access to custom fields can be controlled based on user or group permissions. When read access is allowed, Custom field information is returned as described above. When read access is not allowed, no custom_fields property will be returned on Tasks, no custom_field_settings property will be returned on Projects, and requests to the /custom_field_settings and /custom_fields will return an error such as HTTP code 403 (forbidden). When write access is not allowed, all requests that would modify Custom Fields (for example POST to /project/addCustomFieldSettings or writes to the custom_fields property on Tasks) will return and error such as HTTP code 403 (forbidden). 
       FIG.  6    illustrates a method for managing changes to the data model. At step  610 , a request to add or change a custom field is received from a user. At step  620 , a CustomPropertyProtoSubmission object is created with the default status of “pending” status and the domain id of the user. At step  630 , a CustomPropertyProtoMutations.createOrEdit mutation command is submitted with the id of the newly created submission status object created in step  620 . At step  640 , the request is validated on the server and the associated submission status is updated to either “error” or “success”. If the status is updated to success the custom field object is created and/or updated. Calling the mutation first in step  630  ensures that all requested changes will have finished propagating before the loading indicator is closed. This also allows the validation logic to be executed on the server, instead of performing the checks on the client which likely will not have all Project information. Querying for the success objects on a given proto allows tracking of the revision history for custom fields. 
     The validation logic can be configured as is appropriate for the application. As an example, the system can check if the name for this field match other fields, if the name for this field matches any first-class fields, or any special terms that are forbidden, (such as “Name”, “Description”, etc). Matching can include syntactical processing such as ignoring white-space. 
     The data model also creates the possibility of “orphaned values” that should be addressed. For example, assume that there are two custom fields, “Priority” and “Points”, on a project “A”, and three tasks in that project. If those three tasks have data in them for the two custom fields and if a user removes a task from the project, then it no longer inherits those custom fields. But it is desirable to not lose the data already on those tasks. This problem can occur, for example, when a task is moved to another project, when a task is moved to be a subtask of another task, when a custom filed is removed from project that conferred, or when a project that conferred a custom task is deleted. The embodiment “orphans” the values. In other words, the values are maintained in the data model for the tasks, and the UI is signaled that these fields are no longer inherited by the project. A bubble, or other indicator  710 , can be displayed to the user as shown in  FIG.  7   . 
       FIG.  8    illustrates a method for determining orphaned values. In step  810 , the values the task at issue are loaded. In step  820 , two queries are determined. The first query is to find custom field values on the task and the second query is to find custom field Protos on the projects that task. In step  830 , the two queries are combined, to associate “values which are bestowed by projects in the task” and “values which are orphaned on the task”. 
     Given a list of tasks, a user may want to know the custom properties protos available to those tasks. To derive the properties available to a task, the system will need to determine (1) All of the protos bestowed on this task by its projects, ordered by the ProjectSetting&#39;s rank and (2) All of the values set on a task, since these can be orphaned. Therefore, a consistent ordering algorithm is desirable to order the display of protos in the UI. With such an algorithm, custom fields will be displayed in a consistent order regardless of the various queries used to produce a task list or other display of task information. 
       FIG.  9    illustrates an ordering algorithm. In this example, there are two tasks, A and B, contained in to projects, 1 and 2. Note that each task custom field can be ordered within a project based on metadata as described above. At step  910  protos in task A, project 1 are ordered by rank. At step  920 , protos in task A, project 2 are ordered by rank. At step  930 , protos in task B, project 1 are ordered by rank. At step  940 , protos in task B, project 2 are ordered by rank. At step  960 , orphaned protos in task A are determined and orphaned protos in task B are determined. In other words, values that are set on a task but having protos the are no longer inherited by projects are determined. 
     Another problem that arises when managing tasks across projects is the situation when there are multiple existing tasks with a dropdown field and a user edits the dropdown field to remove one of the dropdown field values. For example, assume there are two existing tasks having the custom field “Primary Sales Team” which is a dropdown field having the possible selected values of “New Business”, “SE”, “ Manager”, and “Sales Ops”. If one of the tasks has the value of “New Business” associated with the filed “Customer Type” and a user modifies the custom field “Customer Type” to remove the “New Business” value selection, this should be handled in a way that does not lose data but which indicates the newly changed drop down selections. 
     In the embodiment, the removed field value is archived to preserve the data associated with the task. Specifically, if a dropdown option is archived, the attribute is_archived is set to “true” on the corresponding CustomPropertyEnumOption object. This allows the value to be reserved but handled differently. For example, when showing dropdown options on the UI, all unarchived options on that dropdown can be displayed. If the value currently set on the task is an archived option, it can be displayed differently in the UI. For example,  FIG.  10    shows a UI displaying the task “An old task” having the archived value of “New Business” which is indicated with a strike through at  1010 . When editing dropdown options, a user can “revive” an archived option by adding a new option with the same name. This automatically makes it so all tasks that previously had this option as a value still have that same option as a value. 
     As noted above, dropdown options are attached to objects in the data model. This yields some very significant user technical advantages. Modifying options causes data on tasks to be continually updated. If a user sets multiple tasks to use option “Red” on dropdown “Color”, and updates the dropdown, then all of those tasks will update accordingly. For example, if a user renames option “Red” to “Rojo”, then the tasks set to “Red” will change to “Rojo”. If a user adds an option color to the option, then all associated tasks will reflect that new color. Reordering options does not “trample” data on existing tasks. For example, there is a dropdown with “Red”, “Green”, “Blue” and a user reorders the options to “Green”, “Red”, “Blue”, existing data on tasks will not change. 
     “Stories” are a record of changes to the task. Stories can be displayed with a task to show a user how the task has evolved over time and who has interacted with the task. For example, a story can show that Bob created the task, assigned it to Charlie and set the due date as July 15, all on July 1, Alice changed the due date of the task to July 30 on July 7, and Charlie marked the task as complete on July 30. 
     Suppose a user, Sue, sets a value “hello” for a custom field “Text Field” on a task. And then a second user, Bob, changes that value to “goodbye” on the same task. In this case, the embodiment can show two “shuffle stories” on the task:
         1. Sue set Test Field to “hello”.Jan 9   2. Bob changed Test Field from “hello” to “goodbye”.3:25 pm       

     However, if Sue sets the value “hello” and then immediately realizes she was mistaken and changes it to “goodbye”, the embodiment will consolidate these two stories together. When a user sets a custom field, the embodiment does the following. It looks backwards in time from most recent story on a task. If a story by a different user is found first, a new story is created. If a story of the same custom field by the same user is found first, and it was created within the last 24 hours (or any other appropriate time period), the story is updated. Otherwise a new story is created. 
     As noted above, because fields are preserved across projects, users can search for tasks by custom fields across multiple projects. For example, a user could search for “Tasks assigned to me, where Priority is P1” to find all of their high priority tasks. In the embodiment, this is implemented by adding custom field data, including the field ID and value, to ElasticSearch indexes, or any other type of search index. Elasticsearch is an open source search engine based on Lucene. The embodiment transforms a user-readable query (like “Priority is P1”) to an ElasticSearch query containing the proto ID and option ID(like “{proto_id: 12345, value: 789}”). For exampleThis works across field types, e.g. a user can search by number fields with “Tasks followed by me, where Cost is greater than 1000”. A user can also use custom fields to filter searches and sort project lists by sorting by custom fields under the “view” menu in the list view (see  FIG.  1   ) of any project. 
       FIG.  11    illustrates an example of a computer architecture that can be used to accomplish the functions disclosed above. The architecture includes server  1120  which can be a web server running Apache or any other server application and which can include one or more computing devices. Client devices  1130 , which can include a web client running a browser and which can include one or more computing devices, communicate with server  1130  over a network, such as the Internet. Each device can be a personal computer, a mobile phone or any other computing device(s). Each device can have a processor for executing computer readable instructions and memory for storing computer readable instructions in a non-transient manner. Client devices  130  can execute a viewer application, such as a web browser, or a native application to exchange data with server  1120 . The various functions noted above can be accomplished on server  1120  or client devices  1130  as appropriate for the specific application. The embodiment take the form of computer executable instructions recorded on non-transient media. Client devices  1130  can be associated with one or more users. 
     Having described and illustrated the principles of our invention with reference to the described embodiments, it will be recognized that the described embodiment can be modified in arrangement and detail without departing from such principles. It should be understood that the programs, processes, or methods described herein are not related or limited to any particular type of computing environment, unless indicated otherwise. Various types of general purpose or specialized computing environments may be used with or perform operations in accordance with the teachings described herein. Elements of the described embodiment shown in software may be implemented in hardware and vice versa. 
     In view of the many possible embodiments to which the principles of our invention may be applied, we claim as our invention all such embodiments as may come within the scope and spirit of the following claims and equivalents thereto.