Abstract:
An embodiment pertains generally to a method of classifying information. The method includes providing for a data object and receiving ownership roles for the data object. The ownership roles establishes at least one user as associated with the data object and a relationship of the at least one user to the data object. The method also includes generating metadata comprising the ownership roles and outputting the metadata to be stored with the data object.

Description:
FIELD 
       [0001]    This invention relates generally to data classification systems, more particularly, to methods and systems for assigning ownership to data. 
       DESCRIPTION OF THE RELATED ART 
       [0002]    The amount of data available to information seekers has grown astronomically, whether as the result of the proliferation of information sources on the Internet, or as a result of private efforts to organize business information within a company, or any of a variety of other causes. As the amount of available data grows, so does the need to be able to categorize or label that data so that the data may be more efficiently searched and a user may determine the relevance of data to them. One approach is to use metadata to identify and classify a data object. 
         [0003]    Metadata is information about the data object such as descriptive attributes of the data object. The metadata can include information such as title of the data object, type of data object, author of the data object, date created, and the like. As used herein, a data object may be any type of instance data (e.g., an electronic mail (“email”) message, email message thread, a website, a text file, an image or a Word document). Data object may also be any type of abstract concept such as an event, project, category, and the like. Operating systems, search mechanisms, and filtering mechanisms may utilize metadata to identify, organize, sort or filter data objects. 
         [0004]    However, the metadata does not truly identify every person responsible for the stewardship and monitoring of the data object. Typically, the metadata may only identify the creator or modifier of the data object. As such, all persons associated with or interested in the data object must monitor the data object to ensure the data object is properly handled. Accordingly, there is a need in the art for a mechanism to allow users to classify ownership of data objects. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0005]    Various features of the embodiments can be more fully appreciated, as the same become better understood with reference to the following detailed description of an embodiment when considered in connection with the accompanying figures, in which: 
           [0006]      FIG. 1  illustrates an exemplary software environment in accordance with an embodiment. 
           [0007]      FIG. 2  illustrates an exemplary ownership module in accordance with another embodiment. 
           [0008]      FIG. 3  illustrates an exemplary interface in accordance with yet another embodiment. 
           [0009]      FIG. 4  illustrates an exemplary interface in accordance with yet another embodiment. 
           [0010]      FIG. 5  illustrates an exemplary process flow of an ownership module in accordance with another embodiment. 
           [0011]      FIG. 6  illustrates another exemplary process flow of an ownership module in accordance with another embodiment. 
           [0012]      FIG. 7  illustrates an exemplary computer platform in accordance with another embodiment. 
       
    
    
     DETAILED DESCRIPTION OF EMBODIMENTS 
       [0013]    For simplicity and illustrative purposes, the principles of the present invention are described by referring mainly to exemplary embodiments thereof. However, one of ordinary skill in the art would readily recognize that the same principles are equally applicable to, and can be implemented in, all types of computing systems, and that any such variations do not depart from the true spirit and scope of the present invention. Moreover, in the following detailed description, references are made to the accompanying figures, which illustrate specific embodiments. Electrical, mechanical, logical and structural changes may be made to the embodiments without departing from the spirit and scope of the present invention. The following detailed description is, therefore, not to be taken in a limiting sense and the scope of the present invention is defined by the appended claims and their equivalents. 
         [0014]    Business enterprises have developed systems for classifying projects and tasks based on peoples relationship to the project or task. Business organizations utilize a RACI model to describe the roles and responsibilities of various teams or people involved in delivering a project or task. It is especially useful in clarifying roles and responsibilities in cross-functional/departmental projects and initiatives. RACI is an acronym for the ownership roles in the RACI model. The RACI model typically includes four ownership roles: responsible—persons who perform work to achieve the project; accountable—persons ultimately accountable for the completion of the project; consulted—persons whose opinions are sought; informed—persons who are kept up-to-date on progress. 
         [0015]    Embodiments relate generally to systems and methods for applying ownership to a data object. More particularly, an ownership classification module can include a RACI engine. The RACI engine can be configured to apply RACI ownership roles to data objects. The data objects can include any type of data (e.g., an email, email thread, forum, a website, a text file, an image or a Word document), each data type having a respective application (browser, electronic mail, spreadsheet, content repository, etc.) The data object can also include abstract concepts such as events, projects, dates, places, and the like. 
         [0016]    While a user has a data object opened in an application, a user can activate a menu icon within the application to activate the ownership classification module. The ownership classification module can display a graphical user interface, e.g., a dialog box, for the user to apply RACI ownership roles to the data object. The RACI engine can receive RACI ownership roles for the data object from the user. The RACI ownership roles can include an association of different users with the levels of the RACI model, i.e., at least one user responsible for the data object; at least one user accountable for the data object; at least one user consulted about the data object; and at least one user informed about the data object. 
         [0017]    After the user completes associating ownership to the data object, the ownership classification module can save the RACI ownership roles as metadata for the data object. Additionally, the RACI engine can store the RACI roles associated with an identification of the data object or a link to the data object in a repository, database or similar device. Also, the RACI engine can notify different users associated with a RACI roles about events with the data object. 
         [0018]    The ownership classification module can also comprise a search engine. A user can use the search engine to formulate a query with information such as a user&#39;s name or data object. The search engine can then return a list of data objects associated with the user&#39;s name and the RACI roles for a data object. The search engine can also return a link to the found data object. 
         [0019]      FIG. 1  illustrates an exemplary software environment  100  in accordance with an embodiment. It should be readily apparent to those of ordinary skill in the art that software environment  100  depicted in  FIG. 1  represents a generalized schematic illustration and that other components may be added or existing components may be removed or modified. 
         [0020]    As shown in  FIG. 1 , software environment  100  can include an operating system  105 . Operating system  105  can be a version of a Linux™, UNIX™, Windows™, or similar multi-tasking, multi-user operating system. A run-time environment (not shown) can be configured to execute on operating system  105 . The run-time environment may provide a set of software that supports the execution of applications/programs. The run-time environment can also comprise an application program interface (“API”)  110  and a complementary API (not shown) within an application space  115 . API  110  can be configured to provide a set of routines that application space  115  uses to request lower-level services performed by operating system  105 . Operating system  105  can include a kernel (not shown). The kernel can be configured to provide secure access to the underlying hardware of a processor. 
         [0021]    Application space  115  can represent the space where a user can execute applications given the allotted memory space as determined by a system administrators of software environment  100 . Within application space  115 , a user can open and execute a number of applications  120 . Applications  120  that can be executed within application space  115  can be a wide variety from databases, electronic mail, customer relationship management programs, utilities, browsers, multi-media application, word processing applications, spreadsheet applications, etc. Each of applications  120  has data objects, such as a native file and/or document format, that is associated with the respective application. For example, Microsoft Word™ has default document format, a Word document. Similarly, Adobe™ has a default document type, “pdf” file, as another example. 
         [0022]    Software environment  100  can further include a ownership module  130 . Ownership classification module  130  can be configured to include a RACI engine (not shown). The RACI engine can be configured to apply RACI ownership roles to data objects. The data objects can include any type of data (e.g., an email, email thread, a website, a text file, an image or a Word document), each data type having a respective application (browser, electronic mail, spreadsheet, content repository, etc.) The data object can also include abstract concepts such as events, projects, dates, places, and the like. 
         [0023]    While a user has a data object opened in an application, a user can activate a menu icon or equivalent action, such as keyboard action, macros, etc., within the application to activate ownership classification module  130 . Ownership classification module  130  can display a graphical user interface, e.g., a dialog box, for the user to apply RACI ownership roles to the data object. The RACI engine can receive RACI ownership roles for the data object from the user. The RACI ownership roles can include an association of different users with the levels of the RACI model, i.e., at least one user responsible for the data object; at least one user accountable for the data object; at least one user consulted about the data object; and at least one user informed about the data object. 
         [0024]    After the user completes associating ownership to the data object, ownership classification module  130  can save the RACI ownership roles as metadata for the data object. Additionally, the RACI engine can store the RACI roles for the respective data object in a repository, database or similar device. Also, the RACI engine can notify different users associated with a RACI roles about events with the data object. 
         [0025]    Ownership classification module  130  can also comprise a search engine (not shown). A user can use the search engine to formulate a query with information such as a user&#39;s name or data object. The search engine can then return a list of data objects associated with the user&#39;s name and the RACI roles for a data object. The search engine can also return a link to the found data object. 
         [0026]      FIG. 2  depicts a more detailed block diagram  200  of ownership classification module  130  in accordance with another embodiment. It should be readily apparent to those of ordinary skill in the art that the diagram depicted in  FIG. 2  represents a generalized schematic illustration and that other components may be added or existing components may be removed or modified. 
         [0027]    As shown in  FIG. 2 , ownership classification module  130  can comprise a RACI engine  205 , a ownership interface  210 , a repository  215 , a search engine  220 , and a messaging module  225 . Modules  205 - 225  of ownership classification module  130  can be implemented as software components, hardware components or combinations thereof. More particularly, modules  205 - 225  can be implemented using conventional programming languages (e.g., Pascal, FORTRAN, etc.), objected oriented programming languages (e.g., C++), Java, PHP, Perl, or other similar languages. Modules  205 - 225  can also be implemented as hardware components such as an application specific integrated circuit, a programmable read-only memory, an EEPROM, a microcontroller, a microprocessor or other similar computing platform. 
         [0028]    RACI engine  205  can be configured to manage modules  210 - 225  to provide the functionality of ownership classification module  130  as previously described and further described herein below. RACI engine  205  can be configured, among other things, to receive ownership roles to be applied to a data object from a user and to associate the ownership roles with data object. RACI engine  205  can be configured to store the ownership roles as metadata with the data object. RACI engine  205  can also be configured to store ownership roles associated with the data object in the repository  215 . 
         [0029]    In particular, RACI engine  205  can be configured to receive and apply information for the four levels of ownership in the RACI model: responsible, accountable, consulted, and informed. The information for each ownership role can include a user or users assigned to the particular level in the RACI model. 
         [0030]    To receive ownership roles, RACI engine  205  can be configured to generate graphical user interfaces (GUIs) and/or graphical widgets for a user to interface with ownership classification module  130 , as shown in  FIG. 3 . In some embodiments, ownership classification module  130  can include a user interface module to generate the appropriate graphical user interfaces. 
         [0031]      FIG. 3  is a diagram illustrating an exemplary GUI  300  for entering ownership roles in accordance with embodiments. It should be readily apparent to those of ordinary skill in the art that the diagram depicted in  FIG. 3  represents a generalized schematic illustration and that other components may be added or existing components may be removed or modified. 
         [0032]    As illustrated, GUI  300  can include an identification text field  305 , description text field  310 , responsible text fields  315 , add additional responsible widget  320 , accountable text fields  325 , add additional accountable widget  330 , consulted text fields  335 , add additional consulted widget  340 , informed text fields  345 , add informed widget  350 , and submit widget  355 . 
         [0033]    Identification text field  305  can display static text language that identifies the data object, such as file name. Description text field  310  is an editable text field that allows the user to enter a description of the data object or comments on the data object. Responsible text fields  315 , accountable text fields  325 , consulted text fields  335 , and informed text fields  345  are editable text field that allow the user to associate users with the ownership roles. 
         [0034]    If the user needs to enter more users than text fields displayed, the user may activate add additional responsible widget  320 , add additional accountable widget  330 , add additional consulted widget  340 , or add informed widget  350  to display additional editable text fields. Once the user has entered all the information, the user can activate the submit widget  355  to transfer the information of GUI  300  to RACI engine  205 . 
         [0035]    Returning to  FIG. 2 , if ownership roles already exist for a data object, RACI engine  205  can generate a GUI for a user to update ownership roles for a data object, as illustrated in  FIG. 4 . In some embodiments, ownership classification module  130  can include a user interface module to generate the appropriate graphical user interfaces. 
         [0036]      FIG. 4  is a diagram illustrating an exemplary GUI  400  for updating ownership roles in accordance with embodiments. It should be readily apparent to those of ordinary skill in the art that the diagram depicted in  FIG. 4  represents a generalized schematic illustration and that other components may be added or existing components may be removed or modified. 
         [0037]    As illustrated, GUI  400  can include an identification text field  405 , description text field  410 , existing responsible text fields  411 , edit existing responsible widget  412 , responsible text fields  415 , add additional responsible widget  420 , existing accountable text field  421 , edit existing accountable widget  422 , accountable text fields  425 , add additional accountable widget  430 , existing consulted text field  431 , edit existing consulted widget  432 , consulted text fields  435 , add additional consulted widget  440 , existing informed text field  441 , edit existing informed widget  442 , informed text fields  445 , add informed widget  450 , and submit widget  455 . 
         [0038]    Identification text field  405  can display static text language that identifies the data object, such as file name. Description text field  410  is an editable text field that allows the user to enter a description of the data object or comments on the data object and may include previously entered description. 
         [0039]    Existing responsible text fields  411 , existing accountable text field  421 , existing consulted text field  431 , and existing informed text field  441  are text fields that display previously entered users for their respective roles. To edit or remove the existing ownership roles, the user may activate edit existing responsible widget  412 , edit existing accountable widget  422 , edit existing consulted widget  432 , and edit existing informed widget  442  to edit the respective existing ownership role. 
         [0040]    Responsible text fields  415 , accountable text fields  425 , consulted text fields  435 , and informed text fields  445  are editable text field that allow the user to add additional users with the ownership roles. If the user needs to enter more users than text fields displayed, the user may activate add additional responsible widget  420 , add additional accountable widget  430 , add additional consulted widget  440 , or add informed widget  450  to display additional editable text fields. Once the user has entered all the information, the user can activate the submit widget  455  to transfer the information of GUI  400  to RACI engine  205 . 
         [0041]    Returning to  FIG. 2 , RACI engine  205  can be configured to authenticate the user adding or update ownership roles. RACI engine  205  can utilize well-known authentication and cryptographic methods to authenticate, such as user name and passwords. If ownership roles already exist for a data object, RACI engine  205  can authenticate a user based on the ownership roles. For example, RACI engine  205  can allow users classified as responsible or accountable to modify ownership roles. 
         [0042]    RACI engine  205  can be coupled to ownership application interface  210 . Ownership application interface  210  can be configured to provide an interface to applications  120 . More particularly, a menu icon that is linked to ownership application interface  210  can be configured to be installed with applications  120 . In some instances, applications  120  can be open source applications, which allow these configuration/installation modifications. If applications  120  are proprietary applications, i.e., not open source, applications  120  can permit the same configuration/installation modification depending on their published application program interfaces. When the menu icon is activated, ownership application interface  210  can receive the name of the activating application as well as a link to the data object that is opened in the activating application. 
         [0043]    RACI engine  205  can be further coupled to repository  215 . Repository  215  can be configured to store ownership roles created by RACI engine  205  and to provide a searchable data structure to retrieve previously stored ownership roles. For example, the data structure can comprise a unique identifier of the data object, the application associated with the data object, a link to the data object, and the applied ownership roles of the data object. Repository  215  can be implemented as a database using open source technologies, proprietary technologies, or combinations thereof. 
         [0044]    Ownership classification module  130  can include a search engine  220 . Search engine  220  can be an independent module  220  or be part of repository  215  in some embodiments. Search engine  220  can be configured to receive a query from a user that includes search topics such as data objects, ownership roles, application types, and the like. Search engine  220  can then be configured to search repository  215  for entries which may include the search topics. 
         [0045]    Search engine  220  can then compile a list of matching entries and temporarily buffer the list of matching entries. Subsequently, search engine  220  can extract the entries that can include the identification of the data object, link to the data object, ownership roles applied to the data object, etc. Search engine  220  can display the list of matching entries. A user can review the list and activate the link to bring up the data object in its native application. In some embodiments, the user can preview the data object by placing a mouse over the respective entry and bring up a thumbnail image of the data object or ownership roles of the data object. 
         [0046]    Ownership module  130  can include a messaging module  225 . Messaging module  225  can be configured to notify the users assigned in ownership roles of data object that an event has occurred with the data object. Messaging module  225  can notify the users based on their assigned role in the RACI model. For example, if the data object is a web page, message module  225  can notify users classified as responsible and accountable that a web page has been updated. 
         [0047]      FIG. 5  depicts an exemplary ownership classification flow diagram  500  implemented by RACI engine  205  in accordance with another embodiment. It should be readily apparent to those of ordinary skill in the art that the flow diagram  500  depicted in  FIG. 5  represents a generalized schematic illustration and that other steps may be added or existing steps may be removed or modified. 
         [0048]    As shown in  FIG. 5 , RACI engine  205  can be configured to receive a request to apply ownership roles with a data object, in step  505 . More specifically, RACI engine  205  can be invoked when a user activates a menu icon within a respective application of the data object. The activation of the menu icon can also forward the name of the respective application as well as identification of the data object and any ownership roles previously stored with the data object to RACI engine  205  through ownership application interface  210 . The name of the respective application, identification of the data object, and previously stored ownership roles can be temporarily buffered by RACI engine  205 . 
         [0049]    Optionally, RACI engine  205  can be configured to authenticate the user adding or update ownership roles. RACI engine  205  can utilize well-known authentication and cryptographic methods to authenticate, such as user name and passwords. If ownership roles already exist for a data object, RACI engine  205  can authenticate a user based on the ownership roles. For example, RACI engine  205  can allow users classified as responsible or accountable to modify ownership roles. 
         [0050]    Then, RACI engine  205  can determine if ownership roles have been previously established, in step  510 . RACI engine  205  can determine if previously established ownership roles exist by checking for ownership roles received during the request. Additionally, RACI engine  205  can utilize search engine  220  to search repository  215  for previously applied ownership roles for the data object. 
         [0051]    If no previous ownership information exists, RACI engine  205  can also generate a graphical user interface to receive new ownership rules from the user, in step  515 . For example, RACI engine  205  can be configured to generate a GUI, such as a dialog box, that contains four text entry fields for a user to associate user with roles of the RACI model, i.e., at least one user responsible for the data object; at least one user accountable for the data object; at least one user consulted about the data object; and at least one user informed about the data object. 
         [0052]    In step  520 , RACI engine  205  receives the ownership roles from the user. RACI engine  205  can receive the ownership roles via ownership application interface  210 . The user may transmit the ownership roles by activating a submit widget on the GUI. 
         [0053]    Then, in step  525 , RACI engine  205  stores the ownership roles. RACI engine  205  can store the ownership roles by transmitting the ownership roles to the respective application for storage with the data object. Additionally, RACI engine  205  can store the ownership roles in repository  215 . 
         [0054]    If previous ownership information is determined to exist at step  510 , RACI engine  205  can also generate a graphical user interface to receive modified ownership rules from the user, in step  530 . For example, RACI engine  205  can be configured to generate a GUI, such as a dialog box, that contains the previously applied ownership roles and four text entry fields for a user to modify users associated with the roles of the RACI model, i.e., at least one user responsible for the data object; at least one user accountable for the data object; at least one user consulted about the data object; and at least one user informed about the data object. 
         [0055]    In step  535 , RACI engine  205  receives the modified ownership roles from the user. RACI engine  205  can receive the ownership roles via ownership application interface  210 . The user may transmit the ownership roles by activating a submit widget on the GUI. 
         [0056]    Then, in step  540 , RACI engine  205  stores the modified ownership roles. RACI engine  205  can store the ownership roles by transmitting the modified ownership roles to the respective application for storage with the data object. Additionally, RACI engine  205  can store the modified ownership roles in repository  215 . 
         [0057]      FIG. 6  depicts an exemplary ownership classification flow diagram  600  implemented by the search engine  220  in accordance with another embodiment. It should be readily apparent to those of ordinary skill in the art that the flow diagram  600  depicted in  FIG. 6  represents a generalized schematic illustration and that other steps may be added or existing steps may be removed or modified. 
         [0058]    As shown in  FIG. 6 , search engine  220  can be configured to receive a query from a user in step  605 . More specifically, a user can access search engine  220  of ownership classification module  130  by activating a menu option, command prompt, icon, etc. Search engine  220  can then display a query GUI for a user to enter search topics to search for data objects or ownership roles. The search topics can include data objects, ownership roles, application types, and the like. The query GUI can have a text entry field for users to enter the search topics. In some embodiments, boolean logic can be included in the query GUI to allow for a more focused search with additional search terms. The user can forward the inputted search topics to search engine  220  in response to an activation of a submit widget on the query GUI. Subsequently, search engine  220  can temporarily buffer the query with the search topics. 
         [0059]    In step  610 , search engine  220  can be configured to search repository  215  with the query. The search engine  220  can be configured to temporarily buffer matching entries in repository  215 . 
         [0060]    In step  615 , search engine  220  can then be configured to present the search result list to the user. More specifically, search engine  220  can extract the name of the data object, ownership roles, application for the data object, and a link to the data object to generate the results list. Search engine  220  can display the list of matching data objects, including ownership roles, application for the data object, and the link to the data object. A user can review the list and activate the link to bring up the data object in its native application. In some embodiments, the user can preview the data object by placing a mouse over the respective entry and bring up a thumbnail image of the data object. 
         [0061]      FIG. 7  illustrates an exemplary block diagram of a computing platform  700  where an embodiment may be practiced. The functions of the ownership classification module  130  can be implemented in program code and executed by computing platform  700 . Ownership classification module  130  may be implemented in computer languages such as PASCAL, C, C++, JAVA, etc. 
         [0062]    As shown in  FIG. 7 , computing platform  700  includes one or more processors, such as processor  702  that provide an execution platform for embodiments of ownership classification module  130 . Commands and data from processor  702  are communicated over a communication bus  704 . Computing platform  700  also includes a main memory  706 , such as a Random Access Memory (RAM), where ownership classification module  130  can be executed during runtime, and a secondary memory  708 . Secondary memory  708  includes, for example, a hard disk drive  710  and/or a removable storage drive  712 , representing a floppy diskette drive, a magnetic tape drive, a compact disk drive, etc., where a copy of a computer program embodiment for ownership classification module  130  can be stored. Removable storage drive  712  reads from and/or writes to a removable storage unit  714  in a well-known manner. A user interfaces with the ownership classification module  130  with a keyboard  716 , a mouse  718 , and a display  720 . Display adapter  722  interfaces with the communication bus  704  and display  720 . Display adapter  722  also receives display data from processor  702  and converts the display data into display commands for display  720 . 
         [0063]    Certain embodiments may be performed as a computer program. The computer program may exist in a variety of forms both active and inactive. For example, the computer program can exist as software program(s) comprised of program instructions in source code, object code, executable code or other formats; firmware program(s); or hardware description language (HDL) files. Any of the above can be embodied on a computer readable medium, which include storage devices and signals, in compressed or uncompressed form. Exemplary computer readable storage devices include conventional computer system RAM (random access memory), ROM (read-only memory), EPROM (erasable, programmable ROM), EEPROM (electrically erasable, programmable ROM), and magnetic or optical disks or tapes. Exemplary computer readable signals, whether modulated using a carrier or not, are signals that a computer system hosting or running the present invention can be configured to access, including signals downloaded through the Internet or other networks. Concrete examples of the foregoing include distribution of executable software program(s) of the computer program on a CD-ROM or via Internet download. In a sense, the Internet itself, as an abstract entity, is a computer readable medium. The same is true of computer networks in general. 
         [0064]    While the invention has been described with reference to the exemplary embodiments thereof, those skilled in the art will be able to make various modifications to the described embodiments without departing from the true spirit and scope. The terms and descriptions used herein are set forth by way of illustration only and are not meant as limitations. In particular, although the method has been described by examples, the steps of the method may be performed in a different order than illustrated or simultaneously. Those skilled in the art will recognize that these and other variations are possible within the spirit and scope as defined in the following claims and their equivalents.