File structure for storing content objects in a data repository

[0001] This application is related to the co-pending and commonly assigned patent applications listed below, which were filed herewith on Jan. 21, 2000 and are all incorporated by reference herein:

• • [0002] A System and Method for Creating Compilations of Content Ser. No. 09/489,134
  • [0003] Method and System for Adding Content to a Content Object Stored in a Data Repository Ser. No. 09/489,576
  • [0004] Method and System for Adding User-Provided Content to a Content Object Stored in a Data Repository Ser. No. 09/488,976
  • [0005] Method and System for Moving Content in a Content Object Stored in a Data Repository Ser. No. 09/488,971
  • [0006] Method and System for Removing Content in a Content Object Stored in a Data Repository Ser. No. 09/489,087
  • [0007] Prerequisite Checking in a System for Creating Compilations of Content Ser. No. 09/488,969
  • [0008] Method and System for Preventing Mutually Exclusive Content Entities Stored in a Data Repository to be Included in the Same Compilation of Content Ser. No. 09/489,265
  • [0009] Volume Management Method and System for a Compilation of Content Ser. No. 09/489,090
  • [0010] Method and System for Calculating Cost of a Compilation of Content Ser. No. 09/489,143
  • [0011] Method and System for Storing Hierarchical Content Objects in a Data Repository Ser. No. 09/489,570
  • [0012] Providing a Functional Layer for Facilitating Creation and Manipulation of Compilations of Content Ser. No. 09/489,605
  • [0013] A Hitmask for Querying Hierarchically Related Content Entities Ser. No. 09/489,133
  • [0014] A Method and Configurable Model for Storing Hierarchical Data in a Non-Hierarchical Data Repository Ser. No. 09/489,561

[0015] Appendix A to this application is set forth on a single compact and the material recorded thereon is incorporated by reference herein. The following file is recorded on the compact disc: file name: AppendixA.txt; file size: 107 kB; date of creation: May 16, 2002.

[0016] 1. Field of the Invention

[0017] The present invention relates to content management, and more specifically, to a system, method and program product for creating compilations of content from hierarchical content stored in a data repository.

[0018] 2. Background of the Invention

[0019] Content management systems have enabled content of all types, e.g., text, still images, moving images, and audio content, to be stored digitally. Content management systems include, for example, relational databases, digital libraries, and media servers. They have further provided functions for manipulating the content, e.g., searching and editing capabilities.

[0020] It would be desirable to enable a user to take advantage of vast stores of content to create compilations tailored to the user's needs or desires. For example, a university professor would find value in creating custom textbook tailored to a specific course from prepublished textbooks stored in a content management system. This compilation could be further enhanced to include associated multimedia materials. As another example, a music lover would benefit from a system that allows him to specify musical selections to be included in a custom album. Such systems would have to partition large content objects (e.g., albums, books, videos) into smaller, selectable objects (e.g., musical selection, chapter section, episode) for inclusion in a compilation.

[0021] A web-based system, method and program product are provided for creating a compilation of content stored in a data repository as a group of hierarchically related content entities, managing, displaying, and searching the content, then creating and exporting compilations of content for publication. Also provided are a system, data structure, method, and program product for storing content into a repository for use in creating a compilation of content.

[0022] The content is hierarchical in nature. Accordingly, entities at each level of the hierarchy except the lowest are defined by “containers”. For example, in the case of textual content, the hierarchical structure of the data may include book containers, volume containers, chapter containers, and subsections (noncontainers, because they are at the leaf level of the hierarchy). In the case of audio content, the hierarchical containers may be album, compact disk, and musical selection, and excerpts of the musical selections are defined as noncontainers. In the case of video content, the hierarchical containers may include movies and excerpts from each movie, and frames are defined as noncontainers. If desired, the maximum size of a container may specified. For example, the volume size in a custom book is preferably determined using a threshold value defining maximum amount of content allowable for that container, and a procedure is provided for managing content entities and containers to maintain this maximum.

[0023] The hierarchical data and associated metadata are preferably stored in a digital library that includes search support. A web-based user interface is provided for presenting a user with a plurality of selectable objects, each object representing a subset of the hierarchical data (e.g., chapter subsections, musical excerpts, video excerpts, etc.). The plurality of objects may represent all subsets of the stored content or less than all of the subsets (e.g., categorizing the content and by providing a bookshelf for each category that a user may browse. The user then selects one or more of the objects for inclusion in a compilation (e.g., a custom textbook). Alternatively, the user may search the content by specifying search criteria through the interface. Additionally, the user may create new content, e.g., a new chapter or section, for inclusion in the final compilation by inputting user-provided material through the web interface. The system preferably stores the new content and creates a reusable, selectable object associated with the new content.

[0024] Each noncontainer content object is preferably stored as a separate entity in the data repository. Each content entity is also stored as a row in a digital library index class as a collection of attributes and references to related content entities. Each containter and noncontainer is associated with a unique identifier that preferably includes hierarchical information about its position in the hierarchy.

[0025] As the user selects desired objects for inclusion in a compilation, the system arranges the objects hierarchically, e.g., into volumes, chapters and sections according to the order specified by the user. The system then creates a file object (e.g., a CBO) defining the compilation that contains a list or outline of the content entities selected, their identifiers, order and structure. This file object is stored separately in the data repository.

[0026] The list or outline is presented to the user at the web interface as a table of contents, and may be edited through the interface. For example, the user may add content, delete content, or move content within and across containers. Editing the list or outline redefines the structure of the compilation. Once the user is satisfied with the organization of the compilation, it is submitted it for publication. The submitted compilation is then forwarded to an approval process and is accepted, rejected, or returned to the user with editorial comments appended by the editor.

[0027] An aspect of the invention is the calculation of the compilation's cost by estimating the amount of content it contains and determining a content cost based upon the content estimate. Optionally, a cost is assigned to each content entity in the data repository and these actual costs are summed as part of the cost estimation procedure.

[0028] Another aspect of the invention is to provide permission checking. Occasionally, it may be desired to prevent certain content entities from appearing a same compilation as other content entities. For example, an author may specify that his work can not be published in the same compilation as the work of another author. Permission checking first requires associating each container and noncontainer with any mutually exclusive containers or noncontainers. For example, such association may be achieved by defining a set of rules specifying containers and/or content entities that are mutually exclusive. Upon selection of a container or noncontainer to add to the compilation, the permission checking procedure determines if the container or noncontainer is mutually exclusive of any other containers or content objects, e.g., by consulting the rules. If so, the permission checking procedure then analyzes the compilation outline to determine whether any of the other mutually exclusive containers or noncontainers already exists in the compilation. If so, then the selected container or noncontianer is not added to the compilation and the user is notified that the content selected may not be included in the compilation. Otherwise, the content is added.

[0029] A further aspect of the invention is to provide prerequisite checking, wherein some entities are associated, e.g., by a set of rules, with content objects that are prerequisites to that object (e.g., front or backmatter associated with the subsection such as an introduction, appendix, or bibliography), and wherein selection by the user of an entity prerequisites causes automatic inclusion of all associated prerequisite objects in the final compilation.

[0030] Another aspect of the invention is the provision of a functional layer between the user interface and data repository for facilitating the creation, manipulation, storage and management of content objects in the data repository.

[0031] Another aspect of the invention allows a user to create multiple compilations concurrently. Yet another aspect of the invention allows a user to modify a compilation by creating a clone or copy of the compilation and applying user-specified changes to the copy (e.g., in the creation of a new edition or version of an existing work.)

[0032] Other aspects of the invention include a configurable model for storing hierarchically related data in a relational database, and a data structure for storing the data and associated metadata, whereby the hierarchical relationship of the data is preserved.

[0033] As a further aspect of the invention, queries are executed on the hierarchical containers and noncontainers through an application or user-interface. The results of the independent searches are merged using hit masks. A hit mask is a string of bits, each bit representing a query. For each container and noncontainer in the result set, a hit mask is generated and ones of the bits are set to indicate which of the queries the container or noncontainer satisfies. Container hit masks are OR-ed with their child containers and/or noncontainers to reflect inheritance. Containers and noncontainers with all bits set comprise the merged result set.

[0045] FIG. 1 functionally depicts a system for creating compilations of content. It comprises three parts: a path for inputting content to the data repository (FIG. 2), a path for enabling a user to select content and organization from the data repository through a web-based interface for inclusion in a compilation of content (FIG. 3), and a path that interfaces with a publishing system for creating the compilation of content from the user's specification (FIG. 2). Each path will be described in detail below.

[0046] The present invention will now be described in terms of a specific embodiment for creating custom textbooks. The intended user group comprises university professors, for example. The content stored in the system comprises a plurality of published textbooks, broken down into hierarchically related objects: book, volume, chapter and chapter subsection.

[0047] Using the proposed system in this context, a university professor is able to access content from a collection of textbooks stored in a digital library and select books, volumes, chapters and/or chapter subsections for inclusion in a custom textbook, and is further able to create content objects for inclusion in the final work.

[0048] Although the specific embodiment is provided to facilitate the reader's understanding, it will be understood that present invention is of a much broader scope and may be applied in the creation of compilations of all types of content including text, image, audio and video content.

A. Receiving and Storing Content

[0049] In the exemplary embodiment of the invention, content and other information is input to digital library 20 through the input data path shown in FIG. 2. Briefly, the content and other information is input by a user in at an input interface represented by block 8. In the preferred embodiment, the input content is provided in SGML format, although other formats may be supported if desired. The content is forwarded by input application 8 to a converter 10 for conversion into the format expected by data loader 14.

[0050] After reformatting, converter 10 outputs the reformatted content and other information to a loader application 14. Loader 14 receives and maps the data for storage in the data repository according to a configuration model 12. According to the present example, the data repository is a digital library 20, and the configuration model 12 is specific to the IBM DB2(R) Digital Library data storage model. Loader 14 interfaces with the digital library 20 through the digital library client application 16. Using the configuration model 12, the content loader 14 is able to map the content and other information it receives in a manner appropriate for the structure of the underlying digital library 20. However, the loader 14 of the present invention may be reconfigured for other types of data repositories by defining a configuration model 12 for each data repository used. Thus if the data repository type is later changed, the configuration file 12 can be updated to reconfigure the input path without having to reprogram the loader application 14.

[0051] The elements of the input path will now be described in greater detail.

[0052] 1. Digital Library Examples of digital libraries suitable for use in the present invention are described in commonly owned U.S. Pat. No. 5,787,413 entitled “C++ classes for a digital library” issued to Kauffman et al., and U.S. Pat. No. 5,857,203 entitled “Method and apparatus for dividing, mapping and storing large digital objects in a client/server library system” also issued to Kauffman et al.

[0053] In the preferred embodiment of the present invention, the data repository comprises the commercially available IBM DB2 Digital Library. However, other commercially available data repositories may be used either in combination with, or in lieu of, the DB2 Digital Library

[0054] Digital libraries are used to store and manage a wide variety of digital objects such as documents, graphics, audio, video, spread sheets and word-processing text. A conceptual view of a conventional digital library client/server system is shown in FIG. 3 and includes a library server 44, one or more object servers 48 and a library client 42. Each of the library and object servers and the library client includes an information store. That is, the library server 44 includes a library catalog 46, the is object server 48 includes an object store 50 and the library client 42 includes a client cache 40. The client applications interface to the digital library through an object-oriented API 16. Also, a communications isolator (not shown) is included which allows the library server 44, object server 48 and library client 42 to communicate with one another without concern for complex communications protocols.

[0055] The library server, object servers and library clients are connected by a communications network, such as a wide-area network (WAN), but also can be locally connected via a local area network (LAN). In the conventional library client/server system the library client 42 is typically embodied in a workstation, such as a personal computer, and the library server 44 and object servers 48 are typically embodied in a host processor: generally a mainframe computer environment such as a MVS/ESA environment running under CICS. The library server 44 uses a relational database such as the IBM DB2 Universal Database or the Oracle database as a library catalog 46 to manage digital objects and provide data integrity by maintaining index information and controlling access to objects stored on one or more object servers. Object servers can also use a relational database such as IBM DB2 or the Oracle database to manage their contents. Library servers and object servers run, for example, on AIX and Windows NT.

[0056] Library Server. The library server 44 directs requests from clients to update or query entries in the library catalog 46, which contains object indexes and descriptive information. Library server 44 additionally performs searches and routes requests to the appropriate object server 48 to store, retrieve, and update objects.

[0057] Each user is assigned a set of privileges for access to the library by a system administrator. Library server 44 checks library catalog 46 before processing a request to ensure that the user's name and password are valid, and to ensure that the user has been granted the appropriate privileges to perform the requested action. An example of a library privilege is the ability to delete objects. In typical implementations, there are groups of individuals who need access to the same objects. Therefore, to simplify the process of granting access to objects a system administrator can define patrons as members of a group. When a patron is defined as a member of a group, that patron is able to access any object for which the group has been granted privileges.

[0058] The library server 44 also checks to ensure that the object's owner has granted the patron the privileges needed to do what is requested (e.g., update the object). The owner of an object is the user who first stored the object. When an owner stores an object that owner must specify which other patrons are to have access to the object.

[0059] If a client request involves the storage, retrieval, or update of an object, library server 44 forwards the request to the object server 48 that contains or will store the object(s) referred to in the request based upon information provided by library catalog 46. If the client request is a query of the information stored in library catalog 46, library server 44 will interact only with the library catalog 46 and will not contact object server 20.

[0060] Library Catalog. The library catalog 46 is analogous to a conventional library's card catalog. It is a set of database virtual tables or index classes which contain an index of all the objects stored in the library system and the object servers owning them. Each row of these virtual tables or index classes references one or more stored objects. Implicitly, the first column of each index class contains a unique digital library item identifier (e.g., the IBM DB2 Digital Library ItemID) for the object referenced by its corresponding row. Other information stored in an index class may include textual descriptions for each object, information on the type of object (e.g., image object, spreadsheet, text document), user names and privileges, access authorization data for each object, links between objects, and an object's properties.

[0061] An item is a row in an index class and a part is a file within the object server 48 that is stored in an access managed directory structure. The management access of the directory structure is performed by the object server 48, but the directory structure responsibilities are performed by the operating system (i.e. AIX, NT, MVS).

[0062] The library server 44 contains a parts table 62, as shown in FIG. 4, which resides in the library catalog 46. For each part or object in the library system, library server 44 stores information about that part. As shown in the parts table 62 in FIG. 4, the information stored for a part includes the item identifier (ItemID), a part number (PartID), a representation type (REP type) and an object server ID identifying which object server contains the object. In the presently described embodiment of the invention, the REP type is a default value (FRN$NULL).

[0063] When a part is stored in the conventional client/server library system 20, library server 44 assigns an item ID and a part number, which are 16 bytes and 4 bytes long, respectively. The item ID is a unique identifier for an item (i.e. row in the library server index class) to which the part belongs. For example, an item could represent a folder in which the part represents a document within that folder. Likewise, the part number is a unique identifier for that part.

[0064] The REP type field can be used to indicate the type or class in which the part is classified. For example, if the part is an image stored in a TIFF format, the REP type for that part could indicate that the part is a TIFF formatted image.

[0065] Object Servers. An object server 48 maintains objects stored within the library system. Objects are stored or retrieved from an object store 50 by object server 48. Object server 48 receives requests from library server 44 and communicates with library client 42 to complete the requests. Such a library system can contain several distributed object servers. Referring to FIGS. 3 and 4, the object server field in the library server's parts table 62 indicates the identifier for the object server 48 which owns the part. For example, if the part is stored on object store 50 of object server 48, the object server ID field will contain the identifier for object server 48.

[0066] Each object server 48 contains an object server table 64 as shown in FIG. 4. The object server 48 uses object server table 64 to manage storage of parts in its storage areas, such as the object store 50. Object server table 64 also contains the same item ID, part number and REP type for the part as does the library server parts table 62. The object server table also contains a file name for the part 66, which indicates the location in object store 50 of stored part 66.

[0067] When a user's privileges are defined a default object server can be set for that user. When the user stores an object, it will be stored in his default object server. If it is later determined that an object or a group of objects should be relocated to a different object server, a client application can cause those objects to be moved from one object server to another.

[0068] Library Client. The library client 42 is the interface through which application programs can submit requests to the library system. These can include requests to store objects, update/add descriptors to objects, delete objects and query information in the library catalog. Library requests can be submitted through the library client either individually or in batches.

[0069] The library client 42 includes a client cache 40 used to locally hold copies of objects that have been stored to or retrieved from the object server 48. These local copies allow very fast access to objects and provide a means for communicating between the library client 42 and the servers 44, 48.

[0070] Additional Search Support. IBM DB2 Digital Library includes parametric search support, and is integrated with text search support from the IBM Intelligent Miner for Text. The library server 44 may be further integrated with other search support 52. For example, image querying may be provided by IBM's Query by Image Content(QBIC) technology (see commonly owned U.S. Pat. No. 5,579,471 to Barber et al.).

[0071] In the present example for creating compilations of text, library server 44 is preferably coupled to the IBM Intelligent Miner for Text full text search support, allowing the user to automatically index, search, and retrieve documents based on a full text search. Text Miner allows users to locate documents by searching for words or phrases, abbreviations and acronyms, and proper names. In a typical LAN environment, a text search installation comprises one or more servers and several clients. The text search server program is installed on a machine with other Digital Library components. The text search client resides on client workstations and provides access to the server. Text search runs, for example, on AIX and Windows 95 and NT. In addition to the server and client components, text search uses dictionaries to support the linguistic processing of documents in different languages during indexing and retrieval. Dictionaries are installed on the server workstation, and at each client workstation.

[0072] Data Flow. Referring to FIGS. 3 and 4, when a requesting library client 42 requests an object, or blob, it sends a request to library server 44. Upon receipt of the request library server 44 consults the parts table 62, among other tables, in the library catalog 46 and determines which object server 48 owns and has the requested object stored in its object store 50. The request contains the item ID, part number and REP type of the requested part. Upon receiving the request, object server 48 retrieves the blob from object store 50 by consulting its object server table 64 and sends a copy of it to client 42. Object server 48 stores the blob in client cache 40. When the blob is successfully transmitted to client cache 40 object server 48 sends a response to library server 44 indicating a successful transfer of the blob to client cache 40. Library server 44, in turn, sends a response to requesting library client 42 indicating that the blob was successfully transferred, which allows the client 42 to retrieve the blob from client cache 40 for use by a client application.

[0073] When an application program submits a request for storage of an object in the library system, library client 42 creates a copy of the object in its client cache 40 to allow the appropriate object server 48 to retrieve the object. The library client then sends a storage request to library server 44. Included in the storage request is a handle to the object stored in the client cache 40. The handle is an identifier which is used to locate the object in the client cache.

[0074] Upon receiving the storage request, library server 44 updates tables in library catalog 46, including the parts table 62 shown in FIG. 4, to identify the object server 48 in which the object is to be stored. Typically, the object server 48 is selected by default based on the user's identity. Library server 44 then sends a request to object server 48 to retrieve the blob from the client cache 40 and store it in the object store 50. Included in the request is the handle of the object stored in client cache 40 and the item ID, part number and REP type of the part.

[0075] The object server 48, upon receiving the request to retrieve a copy of the object, retrieves the copy from client cache 40 and stores it in object store 50, then updates its object server table 64 accordingly to indicate a file name for the blob stored in object store 50. The file name uniquely identifies the location of the blob stored in object store 50.

[0076] Upon successfully storing a copy of the blob, object server 48 sends a response to library server 44 to notify it that the object was successfully stored. Library server 44 then updates its tables including the parts table 62 to indicate that the object is successfully stored in object server 48. The library server 44 sends a response to library client 42 indicating that the object was successfully stored so that the library client 42 can take further action based on the fact that the object was successfully stored in object store 50, such as deallocating memory resources for that object in client cache 32.

[0077] 2. Data Model Definition

[0078] Storing content for use in creating a compilation of content first requires defining a Data Model, i.e., the constructs for mapping input content and other information in digital library 20. The data model is dependent on the constructs available within the underlying data repository. It is also defined by the nature of the content and information being input.

[0079] The content to be stored comprises products such as books, albums, images and videos. The content of each of these products may be organized hierarchically. For example, the hierarchy of a book may be defined by its volumes, chapters and chapter subsections. Since it is desired to create compilations of content from selected entities of these products, the content of the input products is partitioned into selectable entities. Information about the hierarchical relationship is also stored in the data repository. In the present example, other information to be stored includes user and content category definitions.

[0080] In the present example, the data repository is a digital library that includes a relational database, and the data model consists of entity groups defining the constructs in which the content is to be organized and stored within the relational database. Each entity group includes index class definitions, and may include part definitions. The parts store the actual content, and outlines describing the hierarchical relationship of the content entities. The index classes define relational tables for storing parametric attributes parametric (i.e. Integer, Float, Date, Time, String, Char, etc.) of the content, programs, and approval requests. The content index classes further include references to the parts containing them.

[0081] There are four entity groups in the present example: the Product Entity Group, the Program Entity Group, the CBO Entity Group and the Request Entity Group. The Product Entity Group defines the constructs for storing prepublished works or “products” in the digital library 20. These products provide the content from which a user can build a compilation of content. The Program Entity Group defines categories for content. In the present example these categories consist of academic programs. For example, “Freshman Engineering” is one program defined in the present example. The CBO Entity Group defines the constructs for storing a compilation of content. The Request Entity Group defines the contructs for storing information about requests for approval of compilations of content.

[0082] The following tables represent index class definitions, i.e., the meta definitions of the index classes. The rows within the figures define the columns of the index classes. For example, the Product_Aux index class contains 8 columns: SeqID, ProductItem, ParentItem, SiblingItem, ChildItem, Keyword, Value and NextValueltem.

[0083] Each primary index class contains a fixed number of columns. The columns of the index class definitions for the primary index classes define the primary index class column name (first column from the left), attribute type (second column), and source of the attribute value for each column of the index class (third column). In some cases, an attribute value is passed to digital library 20 by the loader 14 application, and the second column of the definition table is used to map the external attribute names to the internal digital library attribute names. In other cases, the attributes are program generated, as is indicated by the value “program generated” in column two. In the index class definition tables below, a fourth column has been added to each table to describe each column. It shall be understood, however, that this column is only provided to facilitate the reader's understanding and is not a part of the index class definitions.

[0084] The primary index class columns are restricted to single value attributes. Those columns that are multivalued or were not known when the system was first created are placed into the auxiliary index class.

[0085] The Program Index Class, Product Index Class and Request Index Class each have an associated auxiliary index class (ProgramAux Index Class, ProductAux Index Class, and RequestAux Index Class). Use of auxiliary index classes is generally understood by those skilled in the use of digital libraries. Each row within an auxiliary index class defines an additional (theoretical) column to a ROW in the corresponding primary index class (NOT to the entire primary index class). The column is theoretical in the sense that the digital library 20 does not handle auxiliary index class rows as additional columns in the primary index class. Rather, the API layer 30 provides the mapping mechanism to enable this theoretical column notion. Therefore users perceive these auxiliary index class rows as additional columns for a row, but in actuality they are stored as rows within the auxiliary index class. Theoretically, the primary index class appears as a table containing multiple rows and each row contains the columns defined in the primary index class definition plus those columns defined by rows in the auxiliary index class. In other words, these auxiliary index class columns (a.k.a. theoretical columns) are bound to a row within the primary index class and not the primary index class itself.

[0086] The manner in which an auxiliary index class defines theoretical columns on rows of a primary index class will now be described with reference to the Product Entity auxiliary index class. The ProductItem column (represented as a row in the auxiliary index class definition, below) contains the itemid, a unique identifier for each row in the primary index class. This column forms the linkage between a row within the auxiliary index class and the corresponding row of the primary index class.

[0087] The keyword column of the auxiliary index class (not to be confused with the Keyword column of the auxiliary index class definition) represents the name of the theoretical column to be added to a row of the primary index class. The current domain of theoretical primary index class column names appears in the Keywords column of the product auxiliary index class definition, below (2nd column from left). For example, one theoretical column name is Pub_Med_Type.

[0088] Note: In the present example, the domain is not restricted by the digital library 20 other than that the names must not exceed the length of the keyword column definition. Therefore, the domain of theoretical primary index class column names can be continuously enlarged by simply adding additional columns to the auxiliary index class.

[0089] The Value column contains the value for the theoretical column identified by the auxiliary index class Keyword column.

[0090] In addition to defining additional theoretical primary index class columns, the auxiliary index class can store multiple valued theoretical columns and hierarchical theoretical columns. Similar to theoretical single valued columns, theoretical multiple valued columns can be represented within a relational datastore model by using rows of an auxiliary index class. In the single valued column, only one row is necessary. In the multiple valued column, two or more rows are necessary (1 row for each value needing to be stored). Each value in the multiple valued column is ordered. This order is then used to chain multiple rows within the auxiliary index class together. Furthermore, the NextValueltem column contains the unique identifier of the auxiliary index class row which follows in the multivalued chain.

[0091] For example, if one wishes to store a multivalued column, First_Name with values: Fred and Barney and the auxiliary index class row containing Barney in the Value column has a unique identifier equal to ABC then the NextValueItem column for the row containing Fred in the Value column is ABC. Thus, the NextValueltem serves as the pointer to the next value in the multivalued chain.

[0092] The ParentItem, SiblingItem and ChildItem columns in the auxiliary index class are used to store hierarchical attributes of a row. Since a book's data model is hierarchical, the concept of hierarchical attribute storage/retrieval is crucial. The ParentItem column of a row in the auxiliary index class contains the unique identifier or itemid of another row in the auxiliary index class that holds a parent attribute of the current row. Similar to the multivalued columns, the children of a container are ordered (chained together). The unique identifier of the auxiliary index class row containing the proceding child is stored in the Siblingltem field. A container's first child's unique identifier is stored in the ChildItem column of the container row, thereby constructing a link between the container and first child, first child and second child and all other children after.

[0093] For example, the AC_Group column in the product auxiliary index class is a hierarchical attribute. AC_Group contains child attributes: ACFORMID and NUMBERAC. This inheritance is identifiable by the tabbing of the terms in the keywords column of the figure. Each AC_Group attribute contains an ACFORMID and NUMBERAC. Therefore the AC_Group is a kind of container.

[0094] This attribute family is represented by three rows within the auxiliary index class: one representing an AC_Group, one representing the ACFORMID and one representing the NUMBERAC. The parentItem column for the AC_Group row is blank to indicate that it is a parent attribute, whereas the parentItem column for the ACFORMID and NUMBERAC rows contains the unique identifier of the AC_Group row. The ChildItem column of the AC_Group contains the unique identifier of the ACFORMID row. The SiblingItem column for the ACFORMID contains the unique identifier of the NUMBERAC row. The NUMBERAC row's SiblingItem is left blank representing the last child of AC_Group.

[0095] The Product and CBO Entity Groups are associated with Part definitions, since these entities define constructs for storing content in the digital library 20.

Product Entity Group

[0096] The Product Entity Group includes two index classes: Product Index Class and ProductAux (Auxiliary) Index Class. These index classes define the storage model for existing content products and their associated attributes to be stored. More specifically, they are used to generate a Product Index class in a relational database representing the content products, and the parts containing the actual content, prerequisite material and hierarchical product outline.

[0097] “Product” in this context refers to an existing content product such as a book, album or video. Since users will be selecting excerpts of existing content products to include in a compilation of content, each content product is stored as a group of hierarchically related entities Entities at each hierarchical level of the work except the lowest is defined by containers. In the present example, the containers are “book”, “volume”, and “chapter”. Each container is described by the subentities or “content entities” it contains. For example, each “book.c” container includes references to all chapters denoted by the keyword, “chapter.c”, contained in that textbook product. Similarly, each “chapter.c” container includes references to all sections contained in that chapter. The lowest level of the hierarchy is a “section”. All three entities (book.c, chapter.c and section) are described by a unique sequence identifier. Each entity is represented by a row in the Product Index class.

Product Index Class

[0098] The product index class defines a relational Product Index Class that is populated with a row for each content entity. Thus for textbook products the resulting product index class includes a row for each book, volume, chapter and section. In addition, each associated component for an entity is also represented by a row in the index class This index class is used as a quick reference for obtaining attribute information about each product entity, as well as a reference to the actual part numbers containing the product files.

[0099] Each product entity is assigned a unique identifier or sequence ID. Preferably, the sequence identifier further includes intrinsic information about the hierarchical level of the entity. To illustrate, the sequence ID used to represent textbook components is in the following form:

• • [0100] XXXXXXXXXX.CC.SS
    where XXXXXXXXXX represents a book's ISBN (International Standard Book Number?), CC represents the chapter number (if any) and SS represents the section number (if any). The CC and SS portions of a book entity sequence identifier will be zeroes. Similarly, the SS portion of a chapter entity sequence identifier will be zero. Thus the sequence number of a container serves as a reference to the subentities of that container, since all subentities will share the same ISBN and container reference number. For leaf entities, the sequence number is used as a reference to the entity's actual content in the data repository.

[0101]

Index Class
Attribute
Name	ATR Mapping	Type	Description
SeqID	Seq_ID	Ext..Alpha [32]	Unique sequence identifier for product entity
		INDEXED
EntityType	PSF	Ext..Alpha [32]	Entity type, e.g., book, chapter, section
ParentItem	Program generated	Ext..Alpha [16]	Unique internal ID of any parent entity (e.g. For
			a section entity, the parent would be its chapter
			container)
SiblingItem	Program generated	Ext..Alpha [16]	Unique internal ID of the next sibling entity
			(e.g. For a section entity, the siblings would be
			other sections of the same chapter.
ChildItem	Program generated	Ext..Alpha [16]	Unique internal ID of the first child entity (e.g.
			a chapter entity's children would he the sections
			it contains.
AuxItem	Program generated	Ext..Alpha [16]	Reference to first entry in the auxiliary table for
			this entity
ProgramID	PE_ID	Alpha [4]	Identifier of Program to which the product
	AC_PE_ID		belongs
Status	Status (SGML)	Alpha [1]	Indicates if entity is available for browse,
	AC_Status (AC)		search or use in a CBO
Title	Title	Alpha [250]	Entity title
	AC_Title
Subtitle	Subtitle	Alpha [250]	Entity subtitle, if any
	AC_Subtitle
ISBN	ISBN	Alpha [10]	Product ISBN
	AC_ISBN
CDAOID	CDAOID	Ext. Alpha [8]	Associated component attribute
	AC_CDAOID
YearOfPub	Yr_of_Pub	Numeric [1]	*
	AC_Yr_of_Pub
Edition	Edition	Ext. Alpha [2]	*
	AC_Edition
Revision	Revision	Alpha [2]	*
	AC_Revision
Version	Content_Ver	Ext. Alpha [8]	*
	AC_Content_Ver
PubMediaType		Ext. Alpha [20]	Media type, e.g., compact disk
ContentType	Content_Type	Ext. Alpha [8]	Content type, e.g., SGML
	AC_Content_Type
ContentFilename	Filename	Ext. Alpha [254]	Name of file containing the entity's content
	AC_Graphic_Filename
ImageType	AC_Image_Type	Ext. Alpha [8]	Type of image, e.g., TIF.
CharCount	SGML_Char_Cnt	Numeric [8]	Number of non-markup characters in content
			(used to calculate CBO price)
AC_ImageCount	AC_Image_Cnt	Numeric [3]	Number of associated component images in
			content
AvailabilityDate	Date_of_Availability	Ext. Alpha [10]	Date entity is available for use
	AC_Date_of_Availability
ExpirationDate	Date_of_Expiration	Ext. Alpha [10]	Date entity is no longer available for use
	AC_Date_of_Expiration
CreateDate	Create_Date	Ext. Alpha [14]	Date that table entry was created
	AC_Create_Date
CreatedBy	Created_By	Alpha [8]	Identifier of user who created entry
	AC_CreatedBy
LastModifiedDate	Last_Modified_Date	Ext. Alpha [14]	Last date entry was modified
	AC_Last_Modified—
	Date
LastModifiedBy	Last_Modified_By	Alpha [8]	Identifier of user who last modified entry
	AC_LastModifiedBy
PageCount	Pagecount	Alpha [6]	Actual page count of content (used in CBO
			pricing formula)

Part Structures & Text Indices

[0102] This table defines the digital library parts used to store each entity. For a row that represents a product entity, Part 1 contains the SGML content for a product entity. Parts 5-11 are parts containing subsets of that content that can be searched by Text Miner. The Text Index column contains the Text Miner indices for each of these searchable subsets. For a row that represents an entity's associated component, Part 20 contains the actual associated component file. (e.g., images).

[0103]

Part No.	Description	Test Index
1	Content	None
5	Authored Abstract	EABSTRAC
6	Generated Abstract	EABSTRAC
7	Index Terms	EIXTERMS
8	Key Terms	EIXTERMS
9	Entity Structure Part	None
10	Teaching Concepts	ETEACHCO
11	Concepts Topics	ETOPICS
20	Associated Component	None

ProductAux Index Class

[0104] In the present example, the auxiliary index class is used to define additional columns in specified rows of the Product Index class Specifically, each label in the Keywords column corresponding to the Keyword attribute defines the name of an additional column in the Product Index class The “value” attribute is the attribute type for each of these keywords. Indentations represent nested keywords. The SeqID, ProductItem, ParentItem, SiblingItem and ChildItem attributes specify the rows in the auxiliary Product Index class for storing hierarchical values. In the present example, “Index_Term” is an example of a multi-valued attribute, meaning that there may be more than one index term defined for each program entity. For performance reasons, the values of a multivalued attribute may be stored in separate rows of the Product Index class Thus The “Next ValueItem” attribute identifies the row of the next item in a set of attribute values. Multivalued attributes are structured as linked lists when loaded into digital library 20, and this order is maintained in the auxiliary Product Index class.

[0105]

Index Class
Attribute
Name	Keywords	Type	Description
SeqID	PSF	Ext. Alpha [32]	Sequence ID of entity that this
			attribute belongs to
ProductItem	Program generated	Ext. Alpha [16]	Unique internal ID of the product
			index class row that this attribute
			belongs to
ParentItem	Program generated	Ext. Alpha [16]	Unique internal ID of the auxiliary
			product index class row that is this
			attribute's parent attribute
SiblingItem	Program generated	Ext. Alpha [16]	Unique internal ID of the auxiliary
			product index class row that is this
			attribute's next sibling attribute
ChildItem	Program generated	Ext. Alpha [16]	Unique internal ID of the auxiliary
			product index class row that is the
			first child attribute for this attribute
Keyword	Pub_Med_Type	Alpha [32]	Media type (e.g., compact disk, audio
			tape, paper, etc.)
	AC_Counts		AC (Associated Component)
			attribute group
	ACFORMID		AC type.
	NUMBERAC		The number for each AC type.
	Index_Term		Index term in a product entity
	Key_Term		Key term in a product entity
	Contrib_Group		This group defines properties re: one
	Contrib_Role		contributing author of a prepublished
	Contrib_Title		book. Since a book can have multiple
	Contrib_First_Name		contributors, more than one
	Contrib_Middle_Name		contrib_group of properties can exist
	Contrib_Last_Name		for that book.
	Contrib_Suffix
	Job_Title
	Contrib_Affiliation
	Contrib_Credentials
	Use_Actuals		Switch variable to determine if actual
			or estimated page count is to be used
			in calculating price.
Value	Value depends on specific	Ext. Alpha	Actual value for the keyword above
	attribute keyword above	[254]
NextValueItem	Program generated	Ext. Alpha [16]	Unique ID of the auxiliary product
			index class row that is the next value
			in a multi-valued attribute.

Program Entity Group

[0106] It is sometimes desirable to categorize users and content to facilitate the creation of a compilation. For example, a system user who wishes to compile an album of classical music is not interested in viewing selections from a country music album. Audio content may therefore be categorized according to music type. The user may also be assigned to a particular category, either by default or by personal selection. In a system for creating custom textbooks, subsets are organized according to particular programs or disciplines. For example, prepublished textbooks may be assigned to categories such as Engineering, Mathematics, English, and so on. In the present example, these categories have been defined even more narrowly Freshman Engineering, Sophomore Engineering, etc.

[0107] A Program Entity Group is used to define categories or “programs” to which users and prepublished content can be assigned.

Program Index Class

[0108] The Program Index Class definition below defines a Program Index Class or Program Index class that is populated with a row for each user/content category. This index class is used as a quick reference for obtaining attribute information about each program.

[0109]

Index Class
Attribute Name	ATR Mapping	Type	Description
Program_ID	PE_Program_ID	Alpha [4]	Program identifier, e.g. “FE” is the
		INDEXED	identifier for “Freshman Engineering”
EntityType	PSF	Ext. Alpha	Used when programs are nested to define
		[32]	hierarchical level of each program entity
ParentItem	Program generated	Ext..Alpha	Supporting hierarchical or “parent”
		[16]	programs
Title	PE_Title	Alpha [250]	Program Title
Subtitle	PE_Subtitle	Alpha [250]	Program subtitle, if any
AvgChrPerImage	PE_AC_Avg_Image_Bytes	Numeric [6]	Average characters per image for products
			within this program
AvgChrPerSGMLAC	PE_AC_Avg_SGML_Bytes	Numeric [6]	Average characters per SGML associated
			component for products within this
			program
MaxChrPerUPMTier	PE_Chars_Per_UPM_Tier	Numeric [6]	Maximum number of characters allowed
			for a UPM in this program
Status	PE_Status	Alpha [1]	Status indicating whether program entity
			is currently valid/invalid
CreateDate	PE_CreateDate	Ext..Alpha	Date table entry created
		[14]
CreateBy	PE_CreateBy	Alpha [8]	Identifier of user who created entry
LastModifiedDate	PE_LastModifiedDate	Ext..Alpha	Date entry was last modified
		[14]
LastModifiedBy	PE_LastModifiedBy	Alpha [8]	Identifier of user who last modified entry
SiblingItem	Program generated	Ext..Alpha	Related sibling programs providing
		[16]	support for hierarchical programs.
ChildItem	Program generated	Ext..Alpha	Related child programs, if any, providing
		[16]	support for hierarchical programs.
AuxItem	Program generated	Ext..Alpha	Reference to auxiliary table
		[16]
SeqID	PSF	Ext. Alpha	Unique program identifier, e.g., “FE” for
		[32]	“Freshman Engineering”

[0110]

ProgramAux Index Class
Index Class
Attribute
Name	Keywords	Type	Description
SeqID	PSF	Ext. Alpha	Unique identifier (i.e., Sequence ID)
		[32]	of this row.
ProgramItem	Program generated	Ext..Alpha	Unique internal ID of row within
		[16]	auxiliary program index class that
			this attribute belongs to
ParentItem	Program generated	Ext..Alpha	Unique internal ID of row within
		[16]	auxiliary program index class that this
			attribute's parent attribute belongs to
SiblingItem	Program generated	Ex..Alpha	Unique internal ID of row within
		[16]	auxiliary program index that this
			attribute's next sibling attribute
			belongs to
ChildItem	Program generated	Ext..Alpha	Unique internal ID of row within
		[16]	auxiliary program index that the first
			child attribute for this attribute
			belongs to
Keyword	PE_Req_Count	Alpha [32]	The next available unique identifier
			for a request
	PE_AC_Group		This group defines associated
			component attributes used in the
			pricing formula
	PE_AC_FormID		AC type
	PE_AC_ByteCount		Number of “characters” for that AC
			type
	PE_Price_Group		This group defines more attributes
			used in pricing formula
	PE_Country		Country
	PE_Monetary_Unit		Monetary unit
	PE_Min_Order_Price		Minimum order price
	PE_Base_Cust_Pub_Price		Base price added to every custom
			publication
	PE_Base_UPM_Fee		Base price added when UPM is
			included
	PE_Incr_UPM_Fee		Additional price per UPM pricing
			block
	PE_Source_Price_Per_Page		Price per page for prepublished
			content included
	PE_UPM_Bytes_Per_Page		Number of UPM characters in a page
	PE_Minimum_Page_Limit		Minimum number of pages required
			in a custom publication
	PE_Volume_Page_Limit		Maximum number of pages in a
			volume
Value	Value depends on specific attribute	Ext. Alph
	keyword above	[254]
NextValueItem	Program Generated	Ext..Alpha	Unique internal ID of row within
		[16]	auxiliary program index representing
			the next value of a multi-valued
			attribute.

CustomBookOutline Index Class

[0111] The CustomBookOutline Index Class defines a relational CBO Index Class that includes a row for each compilation of content created. Each row further includes a reference to a part containing a road map or outline of the compilation of content. The index class is used as a quick reference for obtaining attribute information about a compilation, as well as for locating the corresponding part numbers. Again, the attributes are a matter of design choice.

[0112]

Index Class
Attribute Name	Source	Type	Description
ProgramID	Web application	Ext. Alpha [4]	Program identifier
CBOTitle	Web application	Alpha [120]	Custom book title
ApprovalStatus	Program generated	Alpha [1]	Approval status, i.e., active, submitted, approved,
			rejected or printed
UPMCharCount	Program generated	Alpha [8]	Character count of any user-provided content
RightsFee	Program generated	Alpha [8]	License fee
SGMLPageEstimate	Program generated	Alpha [4]	Estimated page count for SGML content
TotalPageEstimate	Program generated	Alpha [4]	Estimaged total page count
PriceEstimate	Program generated	Alpha [8]	Estimated price
ISBN	Program generated	Alpha [10]	Unique ISBN assigned to the custom book at
			submission time.
CreatorID	Program generated	Alpha [20]	Creator's unique identifier
CreatorTS	Program generated	Alpha [14]	Timestamp representing time of current edit
LastModifiedTS	Program generated	Alpha [14]	Timestamp representing time last modified
CBOTerms	Program generated	Ext. Alpha [32]	Name of file containing terms and conditions that
			will apply to custom book?
ActiveCBOPartID	Program generated	Alpha [3]	Part number of active custom book
LastUPMPartID	Program generated	Alpha [3]	Part number of the last user-provided material
			added

Part Structures & Text Indices

[0113] The part definition describes the parts associated with each compilation. In the present example, three parts are defined: part 1 initially containing the custom book outline, part 2 initially containing a backup copy of the custom book outline for use in undo operations, and parts numbered 50 or higher containing user provided material (UPM). (Note: After undo, part 2 becomes the active CBO, and part 1 is the backup. The attribute value of “ActiveCBOPartID” indicates which is of these is currently the active part.) The first UPM added to a custom book is assigned to part 50, the second UPM added is assigned part 51, and so on. The last UPM part number assigned is stored in the CBO Index class defined above and serves two functions. It is a value that is retrieved and incremented each time new UPM is added. In addition, it serves as an indicator of how many parts the custom book currently contains.

[0114]

	Part No.	Description	Text Index
	1	Part number for Active/	None
		Inactive CBO
	2	Part number for Active/	None
		Inactive CBO
	50+	Part numbers for	None
		user-provided content

Request Entity Group

[0115] Whenever a compilation of content is submitted for publication, the Request Entity Group is used to generate an entry in a Request index class corresponding to the submission request. A unique ISBN is assigned to the CBO once it has been approved for publishing. Attributes are a matter of design choice. In the present example, they describe useful information about the custom book such as its unique identifier, author, approval status, price, etc.

Request Index Class

[0116]

Index Class
Attribute	Source	Type	Description
CBOID	Program generated	Ext. Alpha [20]	Unique CBO identifier assigned at submission
			time
Userid	Program generated	Ext. Alpha [20]	Author
ApprovalStatus	Program generated	Alpha [1]	CBO state in the process
			0 - Active
			1 - Submitted
			2 - Approved
			3 - Rejected
			4 - Printed
TotalPrice	Program generated	Numeric [9]	Price of custom book
QtyStudentCopies	Web application	Numeric [4]	Number of student copies requested
QtyDeskCopies	Web application	Numeric [2]	Number of desk copies requested
QtySupplements	Web application	Numeric [2]	Number of books to be used as supplements
NeedByDate	Web application	Ext. Alpha [10]	Date needed by
TermStartDate	Web application	Ext. Alpha [10]	Start date of the school term for which this
			CBO is created
TermName	Web application	Ext. Alpha [20]	E.g., Spring, Fall
University	Web application	Ext. Alpha [100]	University name, e.g., Stanford University
Department	Web application	Ext. Alpha [100]	Department name, e.g., Electrical Engineering
ClassName	Web application	Ext. Alpha [128]	Class name, e.g., Engineering Basics
ClassNumber	Web application	Ext. Alpha [12]	Class number
CourseNumber	Web application	Ext. Aipha [12]	Course number, e.g., 101
ShipToNameTitle	Web application	Ext. Alpha [12]	*
ShipToFirstName	Web application	Ext. Alpha [40]	*
ShipToLastName	Web application	Ext. Alpha [40]	*
ShipToAddrLine1	Web application	Ext. Alpha [40]	*
ShipToAddrLine2	Web application	Ext. Alpha [40]	*
ShipToAddrLine3	Web application	Ext. Alpha [40]	*
ShipToCity	Web application	Ext. Alpha [40]	*
ShipToState	Web appiication	Ext. Alpha [20]	*
ShipToCountry	Web application	Ext. Alpha [20]	*
ShipToPostalCode	Web application	Ext. Alpha [20]	*
PackageISBN	Program generated	Alpha [10]	The ISBN assigned to the entire book. This
			may be different from the ISBN's assigned to
			volumes within the book.
CreateTS	Program generated	Alpha [14]	Time entry created
RequestID	Program generated	Ext. Alpha [16]	Unique request identifier
*Self-explanatory

RequestAux Index Class

[0117] The RequestAux Index Class is used in the present example to add additional columns to designated rows of the Request Index class when a CBO contains more than one volume. More specifically, if greater than one volume exists, the CBO and each volume it contains are each assigned a unique ISBN, and the Volume, VolumeISBN and VolumeID columns are added to the row representing the submission request. The RequestItem, ParentItem, SiblingItem and ChildItem attributes are used to identify the row to which these columns are added.

[0118]

Index Class
Attribute
Name	Source	Type	Description
RequestItem	Program generated	Ext. Alpha [16]	Unique internal ID of row within request index
			class of entity that this attribute belongs to
ParentItem	Program generated	Ext. Alpha [16]	Unique internal ID of row within auxiliary request
			index class of entity that is this attribute's parent
SiblingItem	Program generated	Ext. Alpha [16]	Unique internal ID of row within auxiliary request
			index class of entity that is this attribute's next
			sibling (siblings are ordered)
ChildItem	Program generated	Ext. Alpha [16]	Unique internal ID of row within auxiliary request
			index class of entity that is this attribute's first
			child (children are ordered).
Keyword	Volume	Alpha [32]	The parent attribute of the volume information.
	VolumeISBN		The child attribute of Volume which stores the
			ISBN of the volume.
	VolumeID		unique internal ID of row within request index
			class of volume entity corresponding to this
			volume.
Value	Program generated	Ext. Alpha [254]
NextValueItem	Program generated	Ext. Alpha [16]	Unique internal ID of row within auxiliary request
			index representing the next value of a multi
			valued attribute.

Login/Registration Database Model

[0119] The Users Table simply defines a relational table for storing user information. The fourth column represents if this is a primary key field and the fifth column represents if this is a foreign key field.

[0120]

USERS Table
		Table	Table	Table
Table Column	Table Column	Column Null	Column	Column
Name	Datatype	Option	Is PK	Is FK
USER_ID	VARCHAR2(30)	NOT NULL	Yes	No
DEPT_UD_ID	NUMBER(8)	NULL	No	No
UNIV_UD_ID	NUMBER(8)	NULL	No	No
DEPARTMENT_ID	NUMBER(8)	NULL	No	No
UNIV_ID	NUMBER(8)	NULL	No	No
USERNAME	VARCHAR2(30)	NOT NULL	No	No
PASSWORD	VARCHAR2(30)	NOT NULL	No	No
TITLE	VARCHAR2(100)	NULL	No	No
FIRST_NAME	VARCHAR2(30)	NULL	No	No
LAST_NAME	VARCHAR2(30)	NULL	No	No
ADDRESS1	VARCHAR2(80)	NULL	No	No
ADDRESS2	VARCHAR2(80)	NULL	No	No
ADDRESS3	VARCHAR2(80)	NULL	No	No
CITY	VARCHAR2(50)	NULL	No	No
STATE	VARCHAR2(2)	NULL	No	No
ZIP	VARCHAR2(10)	NULL	No	No
COUNTRY	VARCHAR2(50)	NULL	No	No
PHONE	VARCHAR2(15)	NULL	No	No
EMAIL	VARCHAR2(80)	NOT NULL	No	No
CHALLENGE	VARCHAR2(255)	NOT NULL	No	No
RESPONSE	VARCHAR2(255)	NOT NULL	No	No
SECURITY	CHAR(1)	NOT NULL	No	No
TIMESTAMP	DATE	NULL	No	No
CBO_ID	VARCHAR2(64)	NULL	No	No

USER_CBOS Table
The USER_CBOS table enables a user to have more than one active CBO at a time.

[0121]

		Table	Table	Table
Table Column	Table Column	Column Null	Column	Column
Name	Datatype	Option	Is PK	Is FK
USER_ID	NUMBER(8)	NOT NULL	Yes	No
CBO	VARCHAR2(100)	NULL	No	No
TIMESTAMP	DATE	NULL	No	No

[0122] 3. Input Interface

[0123] An interface 8 is provided to the user for entering information to be stored in digital library 20. Information includes Program categories and prepublished content. The interface can be in a variety of forms, but it must be able to communicate with an OO Api layer 30 which is in the present embodiment comprises a C dll. The interface 8 of the present embodiment is a web based solution consisting of 22, 24, 26 and 28. Alternatively, application code 28 may provide the same function.

[0124] In the present example, each prepublished content product is input as one SGML file. The hierarchical levels within that SGML file are discernible by their delimiting tag types Program information is provided as a field identifying the program for each prepublished content product. The program configuration information is defined in PSF/ATR files and loaded into the datastore using the loader 10.

[0125] 4. Converter

[0126] Converter 10 receives the SGML files and uses the delimiting tags to separate the product entities and associated components. It also builds a file defining the hierarchical relationships of these entities and components, and extracts relevant product attributes. In the present example, the resulting files include four possible file types: a Product Structure File (PSF), Attribute Files (ATR), Content Component Files and Associated Component Files.

[0127] Product Structure Files (PSF). For content, the Product Structure File provides a hierarchical outline of the contents in a prepublished product. More specifically, it is a parsable formatted file listing all of the entities making up a content product (e.g., a book container, volume containers, chapter containers and sections, each identified by its sequence identifier). This file is used as a road map (i.e., a list or table of contents) defining the content, order and hierarchical structure of the prepublished product, thereby relating a product's separately stored content entities. It is stored as a part in digital library 20. An example of a PSF file for a content product is shown below:

[0128]

PRODUCT.C:0130808598.00.00.00
FRONT_AND_BACK_ELEMENT:0130808598.01.01.00
FRONT_AND_BACK_ELEMENT:0130808598.01.02.00
FRONT_AND_BACK_ELEMENT:0130808598.01.03.00
FRONT_AND_BACK_ELEMENT:0130808598.01.04.00
CHAPTER.C:01 30808598.02.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.02.01.00
	SECTION:0130808598.02.02.00
	SECTION:0130808598.02.03.00
	SECTION:0130808598.02.04.00
	SECTION:0130808598.02.05.00
	SECTION:0130808598.02.06.00
	FRONT_AND_BACK_ELEMENT:0130808598.02.07.00
	CHAPTER.C:0130808598.03.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.03.01.00
	SECTION:0130808598.03.02.00
	SECTION:0130808598.03.03.00
	SECTION:0130808598.03.04.00
	SECTION:0130808598.03.05.00
	SECTION:0130808598.03.06.00
	FRONT_AND_BACK_ELEMENT:0130808598.03.07.00
	CHAPTER.C:0130808598.04.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.04.01.00
	SECTION:0130808598.04.02.00
	SECTION:0130808598.04.03.00
	SECTION:0130808598.04.04.00
	SECTION:0130808598.04.05.00
	FRONT_AND_BACK_ELEMENT:0130808598.04.06.00
	CHAPTER.C:0130808598.05.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.05.01.00
	SECTION:0130808598.05.02.00
	SECTION:0130808598.05.03.00
	SECTION:0130808598.05.04.00
	SECTION:0130808598.05.05.00
	SECTION:0130808598.05.06.00
	FRONT_AND_BACK_ELEMENT:0130808598.05.07.00
	CHAPTER.C:0130808598.06.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.06.01.00
	SECTION:0130808598.06.02.00
	SECTION:0130808598.06.03.00
	SECTION:0130808598.06.04.00
	SECTION:0130808598.06.05.00
	SECTION:0130808598.06.06.00
	SECTION:0130808598.06.07.00
	SECTION:0130808598.06.08.00
	FRONT_AND_BACK_ELEMENT:0130808598.06.09.00
	CHAPTER.C:0130808598.07.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.07.01.00
	SECTION:0130808598.07.02.00
	SECTION:0130808598.07.03.00
	SECTION:0130808598.07.04.00
	SECTION:0130808598.07.05.00
	FRONT_AND_BACK_ELEMENT:0130808598.07.06.00
	CHAPTER.C:0130808598.08.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.08.01.00
	SECTION:0130808598.08.02.00
	SECTION:0130808598.08.03.00
	FRONT_AND_BACK_ELEMENT:0130808598.08.04.00
	CHAPTER.C:0130808598.09.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.09.01.00
	SECTION:0130808598.09.02.00
	FRONT_AND_BACK_ELEMENT:0130808598.09.03.00
	CHAPTER.C:0130808598.10.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.10.01.00
	SECTION:0130808598.10.02.00
	SECTION:0130808598.10.03.00
	FRONT_AND_BACK_ELEMENT:0130808598.10.04.00
	CHAPTER.C:0130808598.11.00.00
	FRONT_AND_BACK_ELEMENT:0130808598.11.01.00
	SECTION:0130808598.11.02.00
	SECTION:0130808598.11.03.00
	FRONT_AND_BACK_ELEMENT:0130808598.11.04.00
	FRONT_AND_BACK_ELEMENT:0130808598.12.01.00

For program categories, the PSF file contains the unique program identifier. As an example, the contents of a PSF file for the “Freshman Engineering” program is shown below:

• • [0129] PROGRAM:fe

[0130] Attribute Files (ATR). Attribute files contain metadata about each program or product entity input. This information must be extracted by converter 10. These files are mapped to the program and product index class defined by the Program and Product index classes (using the ELOADER.INI file described below) and stored in digital library 20. There is one attribute file for each program and for each product entity to be stored. Examples of ATR files are shown below. The first is an ATR file for a “book”:

[0131]

;;
;; PRODUCT.C - ATR file - Created: 29 October 1999 21:55:06
;;
;; Seq_ID: 0130808598.00.00.00
;;
!SKU:0000000014595
!ISBN:0130808598
!Title:Engineering Success
!Contrib_Group
!   Contrib_First_Name:Peter
!   Contrib_Last_Name:Schiavone
!   Contrib_Affiliation:University of Alberta
!PE_ID:FE
!Status:0
!Page_Count:0
!Use_Actuals:1
!Yr_of_Pub:1999
!Edition:01
!Revision:00
!Version:01.00
!Created_By:BARKER
!LastModified_By:BARKER

The ATR for chapter 3 of the preceding book is shown below:

[0132]

;;
;; CHAPTER.C - ATR file - Created: 29 October 1999 21:55:09
;;
;; Seq_ID: 0130808598.03.00.00
;;
!SKU:0000000014618
!Title:Introduction to Engineering and Engineering Study
!Authored_Abstract:&Idquo;How much do you know about engineering?Why did you choose to study
engineering?What reasons lead you to believe that you are ready and equipped to study
engineering?What are the main differences between studying at a university and studying in high
school?What new success skills do you need to succeed in engineering study?Can you write down 10
answers to each question I have asked you?Go ahead and try.”
!Authored_Abstract:This is often how I begin my lecture to freshman engineering students enrolled in an
introductory engineering class. After a little thought, most ot them realize just how little they know about
this subject called engineering and (often despite excellent high school averages) how ill equipped they
are to study engineering.
!Authored_Abstract:In this chapter, we address both issues. First, we ask the following questions:What is
engineering?What do engineers do?Why choose to study engineering?
!Authored_Abstract:The answers to these questions are not only interesting and informative, but will help
keep you motivated along the long, hard road to an engineering degree.
!Authored_Abstract:In , we address the question, &Idquo;Are you prepared and equipped for engineering
study?” In doing so, we examine the study skills required to succeed in the university environment.
For many students, the university is the next logical step after high school, the next academic challenge.
Consequently, they expect their freshman year in engineering to be much like another year of high
school-which, of course, it isn’t. In engineering, such an exception often manifests itself in
unacceptably high first-year attrition rates. We address this issue by focusing on what you need to do to
ensure the best possible start to earning your engineering degree. Essentially, you must develop the
necessary:Work strategiesStudy strategiesAttitudesCommunication skillsAbility to work as part of a
teamTime management skills

The ATR for section 3.2 of the same book is shown below:

[0133]

;;
;; SECTION - ATR file - Created: 29 October 1999 21:55:09
;;
;; Seq_ID: 0130808598.03.02.00
;;
!Filename:0130808598.03.02.00.sgm
!CDAOID:AABQHDS0
!Index_Term:engineering
!Index_Term:defined
!Index_Term:engineering, study
!Index_Term:introduction to
!Index_Term:engineering, defined
!Title:What Is Engineering?
!SGML_Char_Cnt:2370
!AC_Counts
	ACFORMID:2
	NUMBERAC:1
!Associated_Component
!	AC_PE_ID:FE
!	AC_CDAOID:AABQHDTO
!	AC_Title:FIG1
!	AC_Image_Type:TIFF
!	AC_Graphic_Filename:HiRes\AABOHDT0.TIF
!	AC_Authored_Abstract:None

The ATR file for the “Freshman Engineering” program is shown below:

[0134]

;;
;Program ID for Freshman Engineering set to “FE”
!PE_Program_ID:FE
!PE_Title:Freshman Engineering
!PE_Subtitle:
!PE_Req_Count:ESOU002300
;!PE_Related_Material:<value>
!PE_AC_Group
!	PE_AC_FormID:1
!	PE_AC_ByteCount:2
!	PE_AC_FormDesc:Inline Graphic
!PE_AC_Group
!	PE_AC_FormID:2
!	PE_AC_ByteCount:1000
!	PE_AC_FormDesc:Display Graphic
!PE_AC_Group
!	PE_AC_FormID:3
!	PE_AC_ByteCount:68
!	PE_AC_FormDesc:Inline Equation
!PE_AC_Group
!	PE_AC_FormID:4
!	PE_AC_ByteCount:180
!	PE_AC_FormDesc:Display Equation
!PE_AC_Group
!	PE_AC_FormID:5
!	PE_AC_ByteCount:2000
!	PE_AC_FormDesc:SGML
!PE_AC_Avg_Image_Bytes:0
!PE_AC_Avg_SGML_Bytes:0
!PE_Chars_Per_UPM_Tier:2000
!PE_Price_Group
!	PE_Country:0
!	PE_Monetary_Unit:USD
!	PE_Min_Order_Price:1000
!	PE_Base_Cust_Pub_Price:1000
!	PE_Base_UPM_Fee:0
!	PE_Incr_UPM_Fee:10
;JDR add 1/21/99
!	PE_Source_Price_Per_Page:10
!	PE_Minimum_Page_Limit:80
!	PE_Volume_Page_Limit:480
!	PE_UPM_Bytes_Per_Page:1000
!PE_Status:F
!PE_CreateDate:1998-12-07
!PE_CreatedBy:UHANAED
!PE_LastModifiedDate:1999-1-19
!PE_LastModifiedBy:UHANAED

[0135] Content Component Files (SGML). Content component files contain the product entities' actual ASCII or binary content that will be stored as parts in digital library 20. In the present example, these files comprise SGML files containing the ASCII text of chapter sections.

[0136] Associated Component Files. Associated Component (AC) Files contain any non-SGML content associated with the product entities. The content in the associated component files is stored as parts in digital library 20.

[0137] Both prepublished content and custom book outlines (CBO's), described below, are represented in the described file format. A feature of this format is that content objects such as a prepublished book or CBO are defined by the PSF file. Thus the PSF file may be used to redefine the content, order and structure of the content object without having to access the content itself. This feature proves useful in creating compilations of content, by simplifying the process for adding, moving and deleting content.

[0138] Composite PSF & ATR Files. Out of the PSF and ATR format comes a third file format that is a composite form of PSF and ATR. For simplicity, this type is also referred to as a PSF+ATR format. One can think of this file as a merge of PSF and ATR files, where attributes from an entity's ATR file have been inserted after that entity in the PSF. For example, it may be desirable to include certain attributes with a PSF file (e.g., author and price). It may be desirable to add certain attributes to the product structure file (e.g., author) when it is stored in the digital library. Accordingly, in the present embodiment, what is stored as “Entity Structure Part” described earlier is actually a composite form of PSF and ATR. For a book or product level entity, this file includes all entities in the book (including the book itself) and their attributes. For a chapter level entity, this file includes all entities in the chapter (including the chapter itself) and their attributes. For a section level entity, this file includes the section entity and its attributes. Attributes are also added to PSF files containing custom compilation outlines created by system users, and Equery result files. In the Equery results files, all of the entities returned are treated flat, namely at the same hierarchical level.

[0139] An example of a composite file format is shown below:

[0140]

Top_Entity 1: sequence_ID
!Attribute1: value
!Attribute2: value
!Attribute3:
!	Subattribute1: value
!	Subattribute2: value
!Attribute4: Value4
	Sub_Entity1: Sequence_ID
	!Attribute1: value
	!Attribute2: value
	Sub_Sub_Entity1: Sequence_ID
	!Attribute1: value
	!Attribute2: value
	Sub_Entity2: Sequence_ID
	!Attribute1: value
	!Attribute2: value

An exemplaryentity structure part stored in Digital Library is provided in Appendix A.

[0141] In the present example, converter 10 is preferably Active System's Attribute Extractor (i.e. AE). Converter 10 creates a load directory for each prepublished content product, identified by that product's ISBN, which contains the product's corresponding Product Structure File (PSF), Attribute Files, Content Component Files and Associated Component Files. It also creates a load directory for each program category, identified by the program identifier and containing the program's corresponding PSF and ATR files. These directories are provided as input to content loader 14.

[0142] 4. Content Loader

[0143] Content loader 14 is a software application for loading the program and prepublished content files described above into the digital library 20. It receives the load directories as input from converter 10, then loads this information into digital library according to a content configuration model 12 defined in the ELOADER.INI configuration file (described below). Content loader 14 interfaces with the digital library content server(s) 18 through the OO API layer 16.

[0144] The content loader 14 has three modes of operation: load, delete and purge.

[0145] Load. The purpose of this mode of operation is to load or reload the Content Entities, Associated Components and Attributes into the digital library 20. All Content Component Files are stored as binary large objects or BLOBs in the digital library object server 48. All Attribute Files are parsed and the resultant parametric data is stored in the digital library server 44.

[0146] As previously noted, the input files to the content loader 14 are a Product Structure File (i.e., a sequence-id.psf), an Attribute file for each product entity loaded (i.e., sequenceid.atr), a file for each Content Component (i.e., sequence-id.sgm) and a file for each Associated Component (i.e., sequenceid.cdaOID.gif)

[0147] The output of the ELoader will be placed into the appropriate index class in the digital library as specified by the configuration model contained in the ELOADER.INI file.

• • [0148] Syntax: ELoader-load <sequence-id>
  • [0149] Example #1: ELoader-load 012345678
    This load command launches loader 14 into load mode. It looks in the load directory identified by an ISBN=“012345678” for all of the Attribute Files, Content Components and Associated Components stored therein, and processes these files.
  • [0150] Example #2: ELoader 012345678.02.00.00
    This load command launches loader 14 into load mode. It looks in the load directory identified by an ISBN=“012345678” for all Attribute Files, Content Components, and Associated Components associated with chapter container “012345678.02.00.00”, and process these files.

[0151] Delete. The purpose of this mode of operation is to delete selected Content Entities, Associated Components and Attributes from the Digital Library. The ELoader will delete all content, attributes, and text index entries from digital library 20 for the ISBN/sequence number specified, as well as all child content and attributes associated with that ISBN/sequence number.

• • [0152] Syntax: ELoader-delete <sequence-id>
  • [0153] Example #1: ELoader-delete 012345678
    This command launches loader 14 into delete mode and deletes all content and attributes for the prepublished content product whose ISBN=“012345678”.
  • [0154] Example #2: ELoader-delete 012345678.02.00.00
    This command launches loader 14 into delete mode and deletes all entities and attributes for the entity whose sequence number=“012345678.02.00.00” as well as all of its children. The rest of the content product remains untouched.

[0155] Purge. The purpose of this mode of operation is to purge Content Entities, Associated Components and Attributes from the Digital Library after a Load that did not complete successfully. Loader 14 deletes all content, attributes, and text index entries from the digital library 20 even though it is in a partially loaded state.

• • [0156] Syntax: ELoader-purge <sequence-id>
  • [0157] Example: ELoader-purge 012345678
    This command launches loader 14 into purge mode and deletes all content and attributes for the prepublished content product whose ISBN=“012345678”.

[0158] 5. Configuration Model

[0159] Configuration model 12 is embodied in a configuration file called ELOADER.INL and associated configuration files that it calls. The configuration files contain all of the switches and parameters necessary to customize the operation of loader 14 to the data model defined above, The primary objective of these files is to minimize the need to change loader 14 program source code if the data model is modified.

[0160] The ELOADER.INI file is organized into several sections with multiple keywords and values in each section. The LOGON and DEBUG sections describe parameters that govern the overall loader operation. The ELOADER section and the Individual Group Sections describe the entity types that have been defined in the exemplary data model (i.e., the Program, Product, CBO and Request entity groups). The Individual Entity Sections describe each entity type that belongs to a given entity group. The ATTRIBUTES section and the Individual Attribute Sections describe the set of attributes that may be loaded for the entities in the data model.

[0161] The ELOADER.INI file, the data model file, and each of the individual GROUP attribute files are in the same format as an Attribute file as shown in the examples. The GROUP file is in the PSF format.

a. Structure

• [0162] LOGON Section. This section specifies the digital library USERID and server names for all operations between content loader 14 and digital library 20.

[0163]

KEYWORD	VALUE	MEANING
LIBRARY	name	The name of the DIGITAL LIBRARY Library
		Server to be used.
USERID	name	The USERID that will be used to logon to
		DIGITAL LIBRARY.
PASSWORD	name	The PASSWORD of the USERID.
TEXT	name	The name of the client instance of the Text
SERVER		Miner server.
MAX HITS	number	The maximum number of hits to be returned by
		EQuery (described subsequently).

• [0164] DEBUG Section. This section specifies internal switch settings that are only used for debugging, testing, and performance analysis.

[0165]

KEYWORD	VALUE	MEANING
TRACE	0	No debug trace will be created.
	1	Create trace of internal activity for debugging.
		This is not a log file.

• [0166] Log files Section. This section specifies the names of the files to be used for logging and debugging.

[0167]

	KEYWORD	VALUE	MEANING
	LOADER	name	Filename for Loader log.
	TRACE	name	Filename for debug trace.

• [0168] ELOADER Section. This section specifies the name of the initialization file containing the full data model with all of its data groups. In other words, it is a pointer to a meta-metadata file.

[0169]

KEYWORD	VALUE	MEANING
DATA MODEL	Name	Filename of a file containing each Group
		name and the name of the Group File.
DEFAULT	Name	Name of the default Group.
GROUP
ROOT ENTITY	Name	String to be concatenated to the unique ISBN
SID		of a content object to obtain the root
		sequence-id.

• [0170] CONTENT CLASSES Section. This section specifies the digital library content class for each of the possible file extensions of associated component files.

[0171]

KEYWORD	VALUE	MEANING
DEFAULT	Name	BINARY if the component contains non-human
CONTENT		readable data.
CLASS		ASCII if the component contains human
		readable data.
File extension	Name	BINARY if the component contains non-human
		readable data.
		ASCII if the component contains human
		readable data.

• [0172] Groups File. This section lists the names of all hierarchical groups of entities within the data model. All entity instances that belong to the same group will be stored in the same set of digital library index classes. This is a convenient way to manage product-related entities separately from other business-related entities. There may be one or more GROUPS in a Groups File.

[0173]

KEYWORD	VALUE	MEANING
GROUP	name	All instances of entities within this Entity group
		will be stored in the same set of digital library
		index classes. The Entity types that belong to this
		group may be specified via ENTITY keywords in
		an Individual Group Section.

• [0174] Individual Group Attribute Files. Each filename in the group attribute files is the value of one of the GROUP keywords in the Groups File. It identifies the data model entities that will be stored together as a related group and the digital library index class names that will be used to store them. There is one Individual Group Section for each GROUP keyword in the Groups File.

[0175]

KEYWORD	VALUE	MEANING
ENTITIES CLASS	name	The digital library index class name that will be
		used to store all instances of entities that belong
		to this group.
ENTITY ID	name	The digital library attribute name in the
		ENTITIES Index Class for a unique identifier for
		the entity. It is assumed to be unique and an
		index.
ENTITY TYPE	name	The digital library attribute name in the
		ENTITIES Index Class for the digital library
		Type ID of the entity.
ENTITY PARENT ID	name	The digital library attribute name in the
		ENTITIES Index Class for the digital library Item
		ID of the parent container of this entity.
ENTITY CHILD ID	name	The DIGITAL LIBRARY Attribute Name in the
		ENTITIES Index Class for the DIGITAL
		LIBRARY Item ID of the first child of this entity.
ENTITY SIBLING ID	name	The DIGITAL LIBRARY Attribute Name in the
		ENTITIES Index Class for the DIGITAL
		LIBRARY Item ID of the first sibling of this
		entity.
ENTITY AUX ID	name	The DIGITAL LIBRARY Attribute Name in the
		ENTITIES Index Class for the first auxiliary
		attribute of this entity.
ENTITY SUBCOMP ID	name	The DIGITAL LIBRARY Attribute Name in the
		ENTITIES Index Class for the first associated
		component of this entity.
ASSOC COMP ATTR	name	The DIGITAL LIBRARY Attribute Name in the
NAME		COMPONENTS Index Class for the DIGITAL
		LIBRARY Item ID of the ENTITIES Index Class
		item that owns the COMPONENT item.
ASSOC COMP ID	name	The DIGITAL LIBRARY Attribute Name in the
ATTR NAME		COMPONENTS Index Class for the DIGITAL
		LIBRARY Item ID of the ENTITIES Index Class
		item that owns the COMPONENT item.
ATTRIBUTES CLASS	name	The DIGITAL LIBRARY Index Class name that
		will be used to store all attributes that are
		hierarchical or have multiple instances.
ATTR ENTITY ID	name	The DIGITAL LIBRARY Attribute Name in the
		ATTRIBUTES Index Class for the DIGITAL
		LIBRARY Item ID of the ENTITIES Index Class
		item that owns the ATTRIBUTE item.
ATTR PARENT ID	name	The DIGITAL LIBRARY Attribute Name in the
		ATTRIBUTES Index Class for the DIGITAL
		LIBRARY Item ID of the parent container of this
		entity.
ATTR CHILD ID	name	The DIGITAL LIBRARY Attribute Name in the
		ATTRIBUTES Index Class for the DIGITAL
		LIBRARY Item ID of the first child container of
		this entity.
ATTR SIBLING ID	name	The DIGITAL LIBRARY Attribute Name in the
		ATTRIBUTES Index Class for the DIGITAL
		LIBRARY Item ID of the next sibling container
		to this entity.
ATTR NEXT VALUE	name	The DIGITAL LIBRARY Attribute Name in the
		ATTRIBUTES Index Class for the DIGITAL
		LIBRARY Item ID of the next value of this
		entity.
ATTR KEYWORD	name	The DIGITAL LIBRARY Attribute Name in the
		ATTRIBUTES Index Class for the attribute
		containing the Attribute's Keyword.
ATTR VALUE	name	The DIGITAL LIBRARY Attribute Name in the
		ATTRIBUTES Index Class for the attribute
		containing the Attribute's Value.
ENTITY	name	Name of the entity type of the root entity.
ENTITY STRUCTURE	Part	Specifies the DIGITAL LIBRARY Part Number
PART	Number	where an internally generated summary of
		attribute values for this entity and all of its
		descendants will be stored.

• [0176] ATTRIBUTE Definitions. Each top-level attribute name that may be present in a Group Attribute file must have keywords defined. Attributes that are part of an attribute hierarchy (i.e. sibling attributes with a parent attribute) are defined by an ATTRIBUTE keyword within the parent's attribute definition.

[0177]

KEYWORD	VALUE	MEANING
ATTRIBUTE		Defines the beginning of a single attribute.
		There may be one or more ATTRIBUTE
		definitions in Group File. Each attribute name
		that may be present in an attribute file must
		have keywords defined.

Attribute Keywords

[0178]

KEY-
WORD	VALUE	MEANING
NAME	name	The attribute name that will be used to identify
		this attribute.
TYPE	ENTITY	The value of this attribute will be stored as a
		Primary attribute in the Entities Index Class of
		the appropriate Entity Group.
	COMP	It uses the DIGITAL LIBRARY attribute
		specified by the DIGITAL LIBRARY NAME
		keyword. The value of this attribute will be
	AUX	stored as a Primary attribute in the Components
		Index Class of the appropriate Entity Group.
		It uses the DIGITAL LIBRARY attribute
		specified by the DIGITAL LIBRARY NAME
		keyword.
	SYS	The value of this attribute will be stored as an
		Auxiliary attribute along with its keyword.
		Depending on its position in the attribute file, it
		will also contain the DIGITAL LIBRARY Item
		ID of either an Entities Index Class or a
		Components Index Class item of the appropriate
		Entity Group.
		The value of this attribute may not be loaded via
		ELoader and it is not explicitly stored in the
		Digital Library. The value of this attribute
		generated by the DIGITAL LIBRARY query
		engine and is available for output by EQuery.
VALUES	1 (default)	This attribute may only have one value. The
		attribute type may be either PRIM or COMP.
	*	This attribute may have zero or more values. The
		attribute type may only be AUX. The values will
		always be retrieved in the same order that they
		are stored.
DE-	INHERIT	If a value is not explicitly specified for this
FAULT		attribute, the current value of the same attribute
		of the parent entity is used when the entity is
	LINK	stored (i.e. early binding).
		If a value is not explicitly specified for this
		attribute, the current value of the same attribute
	NULL	of the parent entity is used when the entity is
		retrieved (i.e. late binding).
		If a value is not explicitly specified for this
		attribute, the value is assumed to be a NULL
		string (i.e. no binding).
FILE	0 (default)	This attribute has a normal text value and is not a
	1	file name. The value of this attribute is a file
		name. In addition to storing the file name as the
		attribute value, the content of the file is stored as
		a DIGITAL LIBRARY part in the Part number
		specified by the PART keyword.
PART	n	If the PART keyword is specified, the value of
		the attribute is either a long string or the contents
		of a file (based on the value of the FILE
		keyword). The value of the PART keyword
		specifies the DIGITAL LIBRARY Part Number
		where value of attribute will be stored. The part
		will be stored with the item that contains the
		attribute value. This type of attribute may be
		searched with Text search, but not parametric
		search.
DL	name	The DIGITAL LIBRARY attribute name that will
NAME		be used to store this attribute. The attribute type
		must be ENTITY or COMP.
SEARCH	P	Allow parametric search. The attribute type must
	T	be ENTITY.
	PT	Allow text search.
		Allow parametric and/or text search. The attribute
		type must be ENTITY.
TEXT	name	The name of the Text Miner index that will be
INDEX		used to index this attribute value.
AT-		The presence of an ATTRIBUTE keyword
TRIBUTE		indicates that the parent attribute has child values.
		The top-level attribute type must be AUX. The
		value of this attribute is the aggregation of all of
		the values of the attributes that are defined by all
		of the attribute values that it contains.

Example of an ELOADER.INI File:

[0179]

!LOGON
!	LIBRARY:LIBSRVRX
!	USERID:chuck
!	PASSWORD:chuck
!	TEXT SERVER:TM
!DEBUG
!	TRACE:1
!LOG FILES
!	LOADER:Emissary.log
!	TRACE:ETrace.log
!ELOADER
!	DATA MODEL:EMISSARY.GROUPS
!	DEFAULT GROUP:PRODUCTS
!	ROOT ENTITY SID:.00.00.00
!CONTENT CLASSES
!	DEFAULT CONTENT CLASS:BINARY
!	tiff:BINARY
!	gif:BINARY
!	jpg:BINARY
!	eps:ASCII
!	sgm:ASCII
!	txt:ASCII
E.GROUPS file:
	GROUP:PRODUCTS
	GROUP:ProgramGroup
ProgramGroup.ATR file for the group ProgramGroup:
	!NAME:PROGRAM
	;Index Class control words
	!ENTITIES CLASS:E_Program
	!ENTITY ID:E_SeqID
	!ENTITY TYPE:E_EntityType
	!ENTITY PARENT ID:S_ParentItem
	!ENTITY CHILD ID:S_ChildItem
	!ENTITY SIBLING ID:S_SiblingItem
	!ENTITY AUX ID:S_AuxItem
	!ENTITY STRUCTURE PART:9
	!ASSOC COMP ATTR NAME:Associated_Component
	!ASSOC COMP ID ATTR NAME:AC_CDAOID
	!ATTRIBUTES CLASS:E_ProgramAux
	!ATTR SEQUENCE ID:E_SeqID
	!ATTR ENTITY ID:S_ProgramItem
	!ATTR PARENT ID:S_ParentItem
	!ATTR CHILD ID:S_ChildItem
	!ATTR SIBLING ID:S_SiblingItem
	!ATTR NEXT VALUE:S_NextValueItem
	!ATTR KEYWORD:S_Keyword
	!ATTR VALUE:S_Value
	;// Data Model “Entity types”
	!ENTITY:PROGRAM
	;// System attributes
	!ATTRIBUTE
	!NAME:Associated_Component
	!TYPE:SYS
	!ATTRIBUTE
	!NAME:AC_CDAOID
	!TYPE:SYS
	!ATTRIBUTE
	!NAME:Hits
	!TYPE:SYS
	!ATTRIBUTE
	!NAME:HitWords
	!TYPE:SYS
	!ATTRIBUTE
	!NAME:Rank
	!TYPE:SYS
	!DL NAME:DKRANK
	;// Data Model “Entity attributes”
	!ATTRIBUTE
	!NAME:PE_Program_ID
	!TYPE:ENTITY
	!DL NAME:E_ProgramID
	!ATTRIBUTE
	!NAME:PE_Title
	!TYPE:ENTITY
	!DL NAME:E_Title
	!ATTRIBUTE
	!NAME:PE_Subtitle
	!TYPE:ENTITY
	!DL NAME:E_Subtitle
	!ATTRIBUTE
	!NAME:PE_AC_Avg_Image_Bytes
	!TYPE:ENTITY
	!DL NAME:E_AvgChrPerImage
	!ATTRIBUTE
	!NAME:PE_AC_Avg_SGML_Bytes
	!TYPE:ENTITY
	!DL NAME:E_AvgChrPerSGMLAC
	!ATTRIBUTE
	!NAME:PE_Chars_Per_UPM_Tier
	!TYPE:ENTITY
	!DL NAME:E_MaxChrPerUpmTier
	!ATTRIBUTE
	!NAME:PE_Req_Count
	!TYPE:AUX
	!VALUES:*
	!ATTRIBUTE
	!NAME:PE_Related_Material
	!TYPE:AUX
	!VALUES:*
	!ATTRIBUTE
	!NAME:PE_AC_Group
	!TYPE:AUX
	!VALUES:*
	!ATTRIBUTE
	!	NAME:PE_AC_FormID
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_AC_ByteCount
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_AC_FormDesc
	!	TYPE:AUX
	!ATTRIBUTE
	!NAME:PE_Price_Group
	!TYPE:AUX
	!VALUES:*
	!ATTRIBUTE
	!	NAME:PE_Country
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Monetary_Unit
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Min_Order_Price
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Base_Cust_Pub_Price
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Base_UPM_Fee
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Incr_UPM_Fee
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Source_Price_Per_Page
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_UPM_Bytes_Per_Page
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Minimum_Page_Limit
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Volume_Page_Limit
	!	TYPE:AUX
	!ATTRIBUTE
	!	NAME:PE_Status
	!	TYPE:ENTITY
	!	DL NAME:E_Status
	!ATTRIBUTE
	!	NAME:PE_CreateDate
	!	TYPE:ENTITY
	!	DL NAME:E_CreateDate
	!ATTRIBUTE
	!	NAME:PE_CreatedBy
	!	TYPE:ENTITY
	!	DL NAME:E_CreatedBy
	!ATTRIBUTE
	!	NAME:PE_LastModifiedDate
	!	TYPE:ENTITY
	!	DL NAME:E_LastModifiedDate
	!ATTRIBUTE
	!	NAME:PE_LastModifiedBy
	!	TYPE:ENTITY
	!	DL NAME:E_LastModifiedBy

PRODUCTS.ATR file for the group PRODUCTS:

[0180]

;Index class info for Products
!ENTITIES CLASS:tmpResource2
!ENTITY ID:SeqID
!ENTITY TYPE:EntityType
!ENTITY PARENT ID:ContainerItem
!ENTITY CHILD ID:ChildItem
!ENTITY SIBLING ID:SiblingItem
!ENTITY SUBCOMP ID:SubcompItem
!ENTITY AUX ID:AuxItem
!ASSOC COMP ATTR NAME:Associated_Component
!ASSOC COMP ID ATTR NAME:OID
!ATTRIBUTES CLASS:tmpAux2
!ATTR ENTITY ID:EResourceItem
!ATTR PARENT ID:ContainerItem
!ATTR CHILD ID:ChildItem
!ATTR SIBLING ID:SiblingItem
!ATTR NEXT VALUE:NextValueItem
!ATTR KEYWORD:EKeyword
!ATTR VALUE:EValue
;Data Model Root Entity Types for Products Group
!ENTITY:Product.c
;Data Model Attributes for Products - i.e., mapping of metadata properties
;from PSF attribute files to data locations in the DL data repository
!ATTRIBUTE
!	NAME:TITLE
!	TYPE:ENTITY
!	DL NAME:Title
!ATTRIBUTE
!	NAME:PRICE
!	TYPE:ENTITY
!	DEFAULT:INHERIT
!	DL NAME:CharCount
!ATTRIBUTE
!	NAME:FILE NAME
!	TYPE:ENTITY
!	DL NAME:ContentFileName
!	FILE:1
!	PART:1
!ATTRIBUTE
!	NAME:INDEX TERM
!	TYPE:AUX
!	PART:5
!	TEXT INDEX:TIXTERM
!ATTRIBUTE
!	NAME:ITEM INDEX
!	TYPE:AUX
!	PART:5
!	TEXT INDEX:TIXTERM
!ATTRIBUTE
!	NAME:AUTHOR
!	TYPE:AUX
!	DEFAULT:INHERIT
!	ATTRIBUTE
!	NAME:NAME
!	TYPE:AUX
!	PART:6
!	TEXT INDEX:TIXTERM
!	ATTRIBUTE
!	NAME:SCHOOL
!	TYPE:AUX
!ATTRIBUTE
!	NAME:Associated_Component
!	TYPE:COMP
!	ATTRIBUTE
!	NAME:OID
!	TYPE:COMP
!	DL NAME:ObjectId
!	ATTRIBUTE
!	NAME:TITLE
!	TYPE:COMP
!	DL NAME:Title
!	ATTRIBUTE
!	NAME:SIZE
!	TYPE:AUX
!	ATTRIBUTE
!	NAME:COMP FILE NAME
!	TYPE:COMP
!	DL NAME:ContentFileName
!	FILE:1
!	PART:1

B. Selecting Content for a Compilation of Content

[0181] The selection path for creating a compilation of content is shown in FIG. 6. This path allows a user to interface with the digital library 20 to retrieve and view content objects stored therein, select objects for inclusion in a compilation of content, create new objects for inclusion in the compilation and for storage in the digital library 20, and submit the completed compilation for approval.

[0182] In brief, block 22 represents a user interface application 22 which preferably runs within a standard web browser. It comprises HTML and Javascript applications that provide a user interface and some amount of application function such as searching, viewing, selecting, creating, editing, and organizing content accessed from the content server(s). The user creates a compilation in the form of a custom content outline (CCO), which is essentially a formatted text document that includes pointers to the actual content to be included in the final compilation. In the current example for creating custom textbooks, the CCO is called a custom book outline or CBO.

[0183] The user-interface application 22 communicates through a web server 26 to an application layer 28. Application layer 28 preferably comprises a set of PERL applications that control some user interface transactions (e.g., login procedures), retrieve data for presentation to the user, perform CCO manipulation and submission, and forward commands to the API Layer to communicate actions requested by the user.

[0184] Application layer 28 accesses the content server(s) 18 via API layer 30. The API layer 30 preferably consists of a collection of C++ routines that perform discrete functions such as the actual CCO manipulation functions and digital library 20 functions (e.g., search and retrieve). It also includes a PERL/C++ glue layer between the C++ routines and application layer 28 for bridging parameter lists between C++ and PERL. The API layer 30 is provided to map digital library 20 more closely to the customer's website and application program workflow. Underneath, this API 30 makes use of the digital library API 16 to query/update/delete and retrieve data from digital library 20.

[0185] 1. Custom Book Outline

[0186] Prior to submission, a custom book outline is preferably an abstract representation of the compilation of content being created. For example, the CBO may be a hierarchical outline of the contents to be included in a compilation of content. At this point, it contains only references to the actual content to be included in the final work. This format is more efficient than pulling in content at creation time because it avoids retrieval and manipulation of large BLOBs of information until the CBO is in its final form.

[0187] In the present example, the CBO at creation time is a formatted text document comprising a parsable formatted file like the “PSF” filetype previously described. Like the content product PSF files, the CBO is merely an outline with references to the content entities to be included therein. One difference is that a CBO may be a composite PSF+ATR filetype, including attributes particular to the CBO such as author and price. This is the case in the present embodiment.

[0188] “Entities” once again refers to the content hierarchy definition For example, the hierarchy definition of a textbook includes containers representing the higher levels of the hierarchy (cbo.c, volume.c and chapter.c). The smallest entity of the hierarchy is a section. Each entity in the CBO is represented by a sequence ID in the same format as previously described with reference to product entities. The sequence ID of a container entity is used to identify all subentities of that container. The sequence ID's of a leaf node is used to reference the actual content associated with that node.

[0189] A CBO according to the present example is stored as a digital library part Its attributes are also contained in a row of a relational CBO index class defined by the Custom Book Outline Index Class, and its unique identifier for this particular implementation is stored in the User Table, although it could also be stored in the CBO index class The User Table contains this reference for the purpose of identifying the current CBO a user is working with. This allows for the user to log off and log back in and return to the previous CBO “work in progress”. The row in the CBO index class includes references to the CBO part number, as well as any associated parts.

[0190] FIG. 7 depicts a row 82 representing a CBO. It includes a CBO identifier, CBO attributes, and pointers to one or more PSF files or “parts” associated with the CBO. The first part contains the parsable formatted text outline representing the compilation of content, which in turn includes references to actual product content making up the CBO. A second part comprises a backup downlevel copy of the first part that is used to undo previous transactions. A third part, designated with the number 50 or higher, represents any user-provided content that has been added to the CBO. Each part of this type includes pointers to the actual user-provided content, which is stored in digital library 20.

[0191] An example of a CBO is shown below.

[0192]

CBO.C:OW1T8$UEB4H3@SE7
!PE_ID:FE
!Title:Student Loans
!Userid:DaveBaer
!Undoable:FALSE
!Product_Type:CBO
!Create_Date:20001209203630
!Last_Modified_Date:20001214113615
!Status:0
!CBO_State_Changed_Date:20001209203630
!UPM_Terms_And_Conditions_Date:20001214 11:36:13
!Acknowledgement:
!Contrib_Group:
!Price:2216
!UPM_Price:1000
!Page_Count:21.8
!Char_Count:186
!Nextchapter:2
!ECtISGMLChrPerPage:3800
!ECtIAvgChrPerImage:0
!ECtIAvgChrPerSMGLAC:0
!ECtIMaxChrPerUPMTier:2000
!ECtISourcePricePerPage:10
!ECtIUPMBasePrice:1000
!ECtIUPMIncrPrice:10
!Country_Code:US
!PE_Volume_Page_Limit:480
!PE_Minimum_Page_Limit:80
!PE_Min_Order_Price:1000
!UPM_Bytes_Per_Page:1000
!Base_Cost:1000
	VOLUME.C:V1
	!UPM_price:0
	!Title:My New ESource Book created on 12/09/2000 at 20:36:28
	Volume Number 1
	!Price:216
	!Product_Type:
	!Publication_Media_Type:
	!Page_Count:21.8
	FRONT_AND_BACK_ELEMENT:
	!Title:Table of Contents
	!Page_Count:6
	!Price:60
	FRONT_AND_BACK_ELEMENT:
	!Title:Preface
	!Page_Count:9
	!Price:90
	CHAPTER.C:C1
	!Title:New Chapter
	!Price:16
	!Page_Count:1.8
	SECTION:0137842244.02.02.00
	!Title: Background Ideas
	!SGML_Char_Cnt:2111
	!PE_ID:FE
	!Page_Count:0.6
	!Info_Generated:1
	!Price:6
	SECTION:0137842244.02.03.00
	!Title:Why Study Engineering Ethics?
	!SGML_Char_Cnt:3905
	!PE_ID:FE
	!Page_Count:1.0
	!Info_Generated:1
	!Price:10
	UPM SECTION:50
	!Title:My New UPM Title
	!SGML_Char_Cnt:186
	!AC_Subdoc_Cnt:0
	!AC_Image_Cnt:0
	!Page_Count:0.2
	!Price:0
	FRONT_AND_BACK_ELEMENT:
	!Title:Index
	!Page_Count:5
	!Price:50

Attributes are identified by the “!” character. The first line contains a 16 byte CBO_ID, i.e., This is the itemid defined previously in the discussion of the digital library 20. The CBO_ID is the unique identifier for each row in the CustomBookOutline index class.

[0193] The outlined structure is primarily defined by lines below the Volume.C container definition and includes the title of the book, a table of contents, a chapter container, two product sections and their corresponding sequence identifiers, and a user provided section and its corresponding part number (UPM SECTION:50). The text above the Volume.C is defining author, pricing, and other desired variables. This format is parsed by the Edit.cgi script within application layer 28 and displayed to the user on a web interface 22 screen.

[0194] A CBO according to the present example is presented to the system user through the web user interface 22 as will be described subsequently.

[0195] 2. Application Layer and API Layer

[0196] Application layer 28 and API layer 30 interoperate to execute a group of functions defined to enable creation, submission and request processing of a CBO. The functions are listed below and described subsequently with reference to specific CBO tasks. Each function is a logical procedure, preferably implemented in C++, that defines a set of function rules and includes calls to digital library functions necessary to perform the function (e.g. Queries, writes, etc.). In other words, each function is an encapsulation of a series of oft-repeated functional steps which facilitates the creation and processing of a CBO. Digital library function calls are made through the digital library Client OO API 42. A definition of digital library 20 OO API function calls utilized by API layer 30 is provided in the “IBM Digital Library Programming Reference Version 2”, Second Edition (September 1997), and rules for making these function calls are provided in the “IBM Digital Library Guide to Object-Oriented and Internet Application Programming Version 2”, Second Edition (September 1997), both available from IBM Corporation.

[0197] Each function in API layer 30 has a corresponding function in application layer 28. In the present embodiment, the application layer functions are implemented as Perl scripts. These scripts receive Perl input parameters from Perl function calls residing in the application layer 28. The Perl scripts translate the Perl arguments received into equivalent C++ parameters and then issue calls to their corresponding C++ functions in API layer 30. The API layer functions then execute the actual function steps and return C++ output parameters to their corresponding Perl functions. The Perl functions then translate the C++ arguments into equivalent Perl arguments.

CBO Functions

• • [0198] ECBOCreate
  • [0199] ECBOClone
  • [0200] ECBOAddContent
  • [0201] ECBONewContainer
  • [0202] ECBORemoveContent
  • [0203] ECBODelete
  • [0204] ECBOMoveContent
  • [0205] ECBORelocateContent
  • [0206] ECBOSetTitle
  • [0207] ECBOGet
  • [0208] ECBOList
  • [0209] ECBOListByCreator
  • [0210] ECBOUndo
  • [0211] ECBOSetState
  • [0212] ECBOAddUPM
  • [0213] ECBOGetUPM
  • [0214] ECBOSetTerms
  • [0215] ECBOSubmit
  • [0216] CBOCheckPolicies
    Prepublished Content Product Support Functions
  • [0217] EProductGetOutline
  • [0218] EProductSetState
  • [0219] EGetHTML
    Miscellaneous Support Functions
  • [0220] EAdminPopulatePageAndPrice
  • [0221] EDLAuthCheck
  • [0222] EGetProgramAttributes

[0223] It is worthwhile noting at this point that the API layer 30 also includes Request functions. In the present embodiment the Request functions (described with reference to the CBO approval path, below), are called by scripts residing in Request Generator 32 rather than application layer 28. However, this architecture is a matter of design choice and the skilled artisan will appreciate that the Request function calls may be contained in the application layer 28 without departing from the essence of the invention.

Request Processing Support Functions

• • [0224] ErequestUpdateStatus
  • [0225] ErequestAssigniSBN
  • [0226] ErequestList
  • [0227] ErequestGet
  • [0228] ErequestExistsforCBO
  • [0229] ErequestGetForCBO

[0230] 3. Creating a Custom Book Outline

[0231] A user creates a custom book outline by selecting content stored in the data repository 20 through a web-based user interface 22. The user is presented with input screens that lead him through registration, system login, and CBO creation, manipulation and submission. The format and content of the screens is defined by HTML passed to the web browser 26 from functional modules residing in application layer 28 that are invoked by the user's actions. The format may be changed if the system is modified for different purposes. Javascripts in the web browser 26 accept the HTML and use it to build web pages according to known methods. The Javascripts add static elements such as vertical and horizontal navigation bars.

[0232] The sequence of events for creating a custom book outline, including a description of the user interface input screens and their underlying functional modules, will now be described.

Login/Create New Account

[0233] A user entering the system of the present invention is first presented with a login screen as shown in FIG. 8A. The format and content of the login screen are defined by a login procedure. The screen includes input fields 104, 106 for receiving a username and password.

[0234] If the user is new to the system, he must first register for a username by clicking on the register button 102. Clicking on register button invokes a registration procedure and brings up a new screen as shown in FIG. 8B containing a plurality of input fields. The user is prompted to enter a desired username and other information that will be stored by the system in connection with the user and may later be used to configure the CBO user interface. In the present example, this information is tailored to a university professor who will be creating a textbook in a particular discipline and includes, for example, his name, address, university, department, challenge question and secret response. It includes most of the information listed in the USERS Table data model.

[0235] Once the user's information is entered, the user clicks on button 110. The information is retrieved and forwarded with additional information such as a timestamp for storage in an account database. The account database may be the relational database 46 associated with library server 44, for example. Alternatively, an auxiliary database may be provided that is linked directly to the application layer 28. In the present example, an auxiliary database was used. The database stores the information according to the template provided by the USERS Table data model.

[0236] A confirmation screen is displayed next as shown in FIG. 8C with the userid and a temporary password. The user may now log into the system by clicking on the login button 112. This action causes the user to be returned to the login screen of FIG. 8A and control to return to the login procedure. The user then enters his new id and password.

[0237] New and returning users complete the login process by clicking on button 108. This action causes a query to be issued to the account database to determine if the username and password match the USER_ID and PASSWORD columns of any rows in the USERS Table. If there is no match, an error message is returned to the user and he is prompted to reenter his ID. If there is a match, the user information is retrieved. This information includes an active CBO_ID. For returning users, it represents the last CBO that the user was working on.

[0238] In the case of a new user logging onto the system for the first time, the ECBOCreate, EDLAuthCheck and ECBOSetState functions described below are invoked.

ECBOCreate

[0239] Description

[0240] This function creates a new, skeleton CBO, populates whatever data that it knows at this time, and then stores it into the Digital Library. This procedure is invoked whenever a user:

• [0241] 1. logs into the web site for the first time
• [0242] 2. clears an active CBO
• [0243] 3. adds a new CBO to his list of CBO's

[0244] Functional Processing

• [0245] 1. Verify that the PROGRAM ID passed is valid.
• [0246] 2. Create a new CBO with the user's userid and generate a temporary title. The CBO is a parsable formatted text (i.e., PSF) file.
• [0247] 3. Mark the CBO status as active (CBO Status=“1”) with a call to ECBOSetState.
• [0248] 4. Extract the Program variables related to pricing and virtual page count, storing them in the CBO (described subsequently).
• [0249] 5. Write the CBO to the digital library 20. Storing a copy of the CBO in the client cache is automatically handled by the digital library client 16.
• [0250] 6. Parameter List

[0251]

	Inputs	Username
		Password
		Hostname
		Program id
		Userid
		Title
		Distribution country
		Monetary unit
		Composition set
	Outputs	CBO id

[0252] Index Classes

• • [0253] CustomBookOutline
  • [0254] Program
  • [0255] ProgramAux
    EDLAuthCheck

[0256] Description

[0257] Before performing any operation, make sure the system-provided datastore login parameters are valid.

[0258] Functional Processing

• [0259] I. Verify that the datastore usemame, password and hostname passed are valid by connecting to the DL datastore.
• [0260] II. Disconnect from the digital library datastore.

[0261] Parameter List

[0262]

	Inputs	DSUsername
		DSPassword
		DSHostname
	Outputs
	Errors	RC_DS_NOCONNECTION
		RC_DS_NOTAUTHORIZED
		RC_SYSTEM_ERROR

[0263] Index Classes

[0264] None.

ECBOSetState

[0265] Description

[0266] This function changes the approval status of a CBO as it moves through the workflow from creation, to submission, to approval/retum/rejection, to printing through the back-end custom publishing process.

[0267] Functional Processing

• [0268] I. Verify that the CBO id passed is valid.
• [0269] II. Verify that the CBO status passed is valid (“1”, “2”, “3”, or “4”).
• [0270] III. Update the CBO status in the active CBO.
• [0271] IV. Remove all Order Requests for the active CBO if the CBO status is being set to Active.

[0272] Parameter List

[0273]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		CBO state
	Outputs
	Errors	RC_SYSTEM_ERROR

[0274] Index Classes

• • [0275] CustomBookOutline
  • [0276] Request
    An new CBO PSF file will look like this:

[0277]

CBO.C:OW1T8$UEB4H3@SE7
!PE_ID:FE
!Title:My New ESource Book created on 12/09/2000 at 20:36:28
!Userid:DaveBaer
!Undoable:FALSE
!Product_Type:CBO
!Create_Date:20001209203630
!Last_Modified_Date:20001209203630
!Status:0
!CBO_State_Changed_Date:20001209203630
!UPM_Terms_And_Conditions_Date:
!Acknowledgement:
!Contrib_Group:
!Price:1000
!UPM_Price:0
!Page_Count:0
!Char_Count:0
!Nextchapter:1
!ECtISGMLChrPerPage:3800
!ECtIAvgChrPerImage:0
!ECtIAVgChrPerSMGLAC:0
!ECtIMaxChrPerUPMTier:2000
!ECtISourcePricePerPage:10
!ECtIUPMBasePrice:1000
!ECtIUPMIncrPrice:10
!Country_Code:US
!PE_Volume_Page_Limit:480
!PE_Minimum_Page_Limit:80
!PE_Min_Order_Price:1000
!UPM_Bytes_Per_Page:1000
!Base_Cost:1000
	VOLUME.C:V1
	!UPM_price:0
	!Title:My New ESource Book created on 12/09/2000 at 20:36:28
	Volume Number 1
	!Price:0
	!Product_Type:
	!Publication_Media_Type:
	!Page_Count:0

[0278] In addition, a cookie is created and stored in the web browser's memory including the user's name, userid, password and active CBO_ID. This cookie is used to establish connections to the content management system as necessary and transparently to the user, according to conventional methods.

[0279] A welcome screen is presented to the new user by a MYBOOKOUTLINE procedure, as shown in FIG. 9A. A first section 111 identifies the user and information about the user—in this case her university name, department and guest access level. A second section 113 lists the user's new custom book outline. The list includes a “My Custom Book” column containing a temporary title and creation date, a “Last Date” column reflecting the CBO's last date of modification, a “Status” column indicating that the CBO is active, and a “Request ID” column that is null at this point to indicate that the CBO has not been submitted for approval.

[0280] The user now has two options: 1) he may select the new CBO for modification by clicking on the temporary CBO title, which is a hypertext link to the new CBO.; or 2) he may create another CBO by clicking on CBO button 118. Button 118 once again invokes the ECBOCreate procedure. Clicking on the CBO title causes the MYBOOKOUTLINE procedure to issue a call to the ECBOGet procedure to retrieve the CBO formatted text from the digital library 20. It then parses the text and displays the empty CBO to the user as shown in FIG. 10A. The ECBOGet procedure is described below.

ECBOGet

[0281] Description

[0282] The content of the custom book outline/ICBO is returned.

[0283] Functional Processing

• [0284] 1. Verify that the CBO id passed is valid.
• [0285] 2. Retrieve content of the CBO.
• [0286] 3. Add Preface and Table of Contents front matter elements to the very beginning of the CBO:
• [0287] 4. Add the Index back matter element to the very end of the CBO:
• [0288] 5. Pricing and virtual page counts are pre-determined for these front or back matter elements and are hard-coded at this time. The attributes are adjusted for the affected Volumes as well as the CBO totals.

[0289] Parameter List

[0290]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
	Outputs	CBO description
	Errors	RC_SYSTEM_ERROR

[0291] Index Classes

• • [0292] CustomBookOutline

[0293] The custom book outline is displayed in a first portion 122 of the screen of FIG. 10A. It includes the temporary title and creation date 128. A “Content” column 130 shows the default format that initially includes the volume, table of contents, preface and index. A price column 132 reflects the price of the compilation calculated thus far, as is determined by prices associated with the elements of column 130. Similarly, a “Pgs” column 134 reflects a page count calculated so far, as determined by page estimates for the elements of column 130.

[0294] The user may elect to return to the Welcome page by clicking on “CBO” button 119. Section 124 of the screen is provided to allow the user to add new chapters to the CBO. This function will be described in more detail subsequently. Section 126 enables the user to change any container (book, volume, chapter) or noncontainer (section) title by selecting the entity type via pull-down menu 125 and inserting the new title in entry field 127, then clicking on “Change” button 129. In the present example, let us assume that the user wishes to change the book title to “Internet Basics”. Entity type “book” has been selected in menu 125 and the desired title has been inserted in field 127. By clicking on button 129, the ECBOSetTitle procedure is invoked, as described below.

ECBOSetTitle

[0295] Description

[0296] This modifies the book and container/chapter titles of the active CBO to whatever the user specifies.

[0297] Functional Processing

• [0298] 1. Verify that the CBO id passed is valid.
• [0299] 2. Verify that the target sequence id passed exists in the CBO. Otherwise, the target becomes the CBO itself.
• [0300] 3. Set the title of the target element within the CBO.
• [0301] 4. When renaming, determine if the title is protected and cannot be changed
• [0302] 5. When renaming, the title text is validated by Javascript on the web page
• [0303] 6. When renaming, the “<” and “>” symbols will be changed to HTML equivalents: “&It”; “&gt”

[0304] Parameter List

[0305]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Target id
		Title
	Outputs	New CBO description
	Errors	RC_SYSTEM_ERROR

[0306] Index Classes

• • [0307] CustomBookOutline

[0308] FIG. 10B shows the CBO with its new title. Let us assume that the user now wishes to add preexisting content to the CBO.

[0309] Adding Prepublished Content to a CBO

[0310] There are two methods for selecting preexisting content viewing a “bookshelf” of content available to the user, or searching the stored content Searching shall be described in more detail subsequently.

[0311] To access a bookshelf, the user clicks on the “Library” tab 136 on the vertical menu bar. This action invokes a BrowseBookshelf procedure to retrieve all or a subset of the prepublished content stored in the digital library 20. For convenience, a subset or “bookshelf” may be tailored to the particular user. In the present example, content is grouped into academic programs such as Engineering, Mathematics, English, etc. Each program is assigned a unique ProgramID, and each program entity's ProgramID is stored in the Product Index class defined by the Product Entity Index Classes. Users are assigned to a program based upon department information entered at the time of system registration.

[0312] An exemplary bookshelf tailored to an Engineering program is shown in the user-interface screen of FIG. 11. It includes a list of prepublished books whose titles are hypertext links to their corresponding PSF files. By clicking on one of these titles 138, the user invokes the EProductGetOutline procedure call which retrieves the PSF file, parses it, and displays it to the user as shown in FIG. 12. The EProductGetOutline function is described below:

EProductGetOutline

[0313] Description

[0314] This returns attribute information about an existing product stored in the digital library. It allows calling applications to retrieve the only the attributes that it needs or all attributes. It will return attributes for all entities within the product hierarchy, exposing the product outline. Sysadmin prepubcall when book becomes public. Returns entire outline/browse of bookshelf

[0315] Functional Processing

• [0316] I. Search for any existing prepublished content product with the product id passed.
• [0317] II. Verify that there is exactly one match for the product id.
• [0318] III. If the attribute list is not null, only those attributes in the list are of interest.
  • [0319] A. Retrieve the requested attributes along with the various levels of entities in the existing copyright product
  • [0320] B. If an attribute of interest is not found for the existing copyright product, an attribute value of null is assumed.
• [0321] IV. If the attribute list is null, all attributes are of interest.
  • [0322] A. Retrieve all attributes along with the various levels of entities in the existing copyright product.
  • [0323] B. Retrieve the program-specific attributes related to pricing and virtual page count.
  • [0324] C. Calculate and update the pricing and virtual page count information for each level of entities in the existing copyright product.
• [0325] V. Export the attributes and entities description into the output buffer.

[0326] Parameter List

[0327]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Product id
		Attribute list
		Distribution country
		Monetary unit
		Composition set
	Outputs	Product description
	Errors	RC_SYSTEM_ERROR

[0328] Index Classes

• • [0329] Product
  • [0330] ProductAux
  • [0331] Program
  • [0332] ProgramAux

[0333] The selected book is displayed by chapter as defined by the PSF format. A chapter may be expanded to view its sections by clicking on its corresponding expand button 141. In FIG. 12, chapters 1 and 7 have been expanded. Each chapter and section is provided with a select box 145. The user selects content for inclusion in his custom book by checking the boxes next to the chapters and sections he desires. In the example of FIG. 12, Chapters 1146 and 7148 have been selected According to the present embodiment, a user can not add chapters and sections at the same time. However, it should be apparent to the user that this implementation is merely a matter of design choice, ant that if desired, chapters and sections could be added at the same time.

[0334] Once selection is complete, the user clicks on the “Add to Book” button 144 on the vertical menu bar. This action adds the selected text to the CBO by invoking the ECBOAddContent procedure described below.

ECBOAddContent

[0335] Description

[0336] There are two types of content: (chapters and sections) also referred to as containers and non-containers that can be added using this function. ECBOAddContent defines separate processes depending on the content type being added.

[0337] This function adds pre-published content into the CBO once the user has selected which content he wants to include in his CBO. The function verifies rights and pre-requisite content before the content is included. Additional volumes are constructed on an as needed basis.

[0338] Functional Processing

• [0339] 1. Verify that the CBO id passed is valid.
• [0340] 2. Check the country code in the CBO.
• [0341] 3. Verify that the CBO chapter location reference is valid if specified.
• [0342] 4. Verify that each piece of content does not already exist in the CBO.
• [0343] 5. For content containers (e.g. Chapter):
  • [0344] a) Retrieve the piece of content by its content id (sequence number).
  • [0345] b) Verify that the piece of content is indeed a container.
  • [0346] c) Validate the right to distribute it.
  • [0347] d) Validate the right to combine it with other contents in the CBO.
  • [0348] e) If the CBO chapter location reference is valid, add the content container after the chapter location reference.
  • [0349] f) If the CBO chapter location reference is null or invalid, add the piece of content to the end of the CBO. This situation occurs when a CBO contains no chapters (a.k.a. empty).
• [0350] 6. For content components (e.g. Sections):
  • [0351] a) Retrieve the piece of content by sequence id.
  • [0352] b) Verify that the piece of content is indeed a non-container.
  • [0353] c) Validate the right to distribute it.
  • [0354] d) Validate the right to combine it with other contents in the CBO.
  • [0355] e) If the CBO chapter location reference is valid, add the piece of content to the end of the chapter location referenced, immediately before any back matter elements in that chapter.
  • [0356] f) If the CBO chapter location reference is null or invalid, return error.
• [0357] 7. For content components (e.g. Section), process prerequisites listed one at a time:
  • [0358] a) Retrieve the piece of prerequisite content by sequence id.
  • [0359] b) Validate the right to distribute it.
  • [0360] c) Validate the right to combine it with other contents in the CBO.
  • [0361] d) If the piece of pre-requisite content does not already exist in the CBO, add it to the end of the chapter location referenced, immediately before any back matter elements. Mark it as pre-requisite, so it cannot be deleted later.
  • [0362] e) If the piece of pre-requisite content already exists in the CBO, but it has never been pre-requisite before, downgrade it to the pre-requisite status so it cannot be deleted later. Location of the piece of pre-requisite content remains unchanged.
  • [0363] f) If the piece of pre-requisite content already exists in the CBO, and is already in pre-requisite status, update the pre-requisite information with the current requiring content id. Location of the piece of pre-requisite content remains unchanged.
• [0364] 9. Perform volume management (described subsequently).
• [0365] 10. Perform pricing and page count calculations (described subsequently).

[0366] Parameter List

[0367]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Content id list
		Content id count
		Container flag
		CBO chapter location reference
	Outputs	New CBO description if OK;
		Offending content ids if error
	Errors	RC_NOT_FOUND
		RC_DUPLICATE_NOT_ALLOWED
		RC_CONTENT_NOT_CHAPTER
		RC_CBO_NO_VOLUME
		RC_INVALID_CBO
		RC_BAD_CHAPTER
		RC_BAD_CONTENT
		RC_INVALID_PREREQ
		RC_NO_DIST_RIGHTS
		RC_NOT_COMB_RIGHTS

[0368] Index Classes

• • [0369] CustomBookOutline
  • [0370] Rights
  • [0371] RightsAux
  • [0372] Prereq
  • [0373] PrereqAux
  • [0374] Product

[0375] Steps 6.d) and 7.c) above are performed to prevent mutually exclusive content entities stored in the digital library from being included the same compilation of content. The substeps necessary to perform this mutual exclusion are defined subsequently. When a content entity is added to a CBO, the Product Index class is referenced to determine if the content entity is mutually exclusive of any other content entities. If it is, then the CBO is checked to determine if any of the mutually exclusive content entities already exists in the compilation. If not, the content entity is added to the compilation, but if a mutually exclusive content entity is present, the add fails and the user is given an error message.

[0376] After the selected content is added to the CBO, the user is returned to the CBO screen and is able to view his new additions (see FIG. 13A). In the present example, the ECBOAddContent procedure has retrieved and inserted the titles of all of the sections 150 of selected chapter 1146 and the selected sections 152 of Chapter 7148, and has assigned new chapter and section numbers accordingly.

[0377] It has also retrieved and inserted references to front and back matter 154 associated with the selected content (e.g., introductory text, summary text and sample problems). Selection boxes 157 are provided next to each chapter title and section title to facilitate further editing of the CBO.

[0378] Let us now assume that the user wishes to add his own content to the CBO.

[0379] Adding User-Provided Content to a CBO

[0380] User Provided Material (UPM) is content an instructor contributes to a CBO that is not part of the pre-published content. UPM consists of two components: title and content. The title of the UPM is inserted into the CBO's index class of contents and added to the content outline. The content is stored as a part in digital library 20. UPM can be added at either the chapter or section level. In other words, UPM can be siblings of chapters or sections.

[0381] The user first selects a location at which the UPM content is to be inserted using pull-down menu 155 (see FIG. 13). In the present example, the user may select to add the UPM to one of the existing chapters or to a new, untitled chapter. New chapter is selected in this case (not shown). The user then clicks on the “Add Content” button 156. This action invokes a UPM procedure which displays a “My Custom Content” screen as shown in FIG. 14. The user enters a title in title field 158, and the UPM content in entry window 160. The content may be designated as standard text or as a code sample. Once the content has been entered, the user clicks on button 162 to add the content to the CBO. This action invokes the ECBOAddUPM procedure described below. In the present example, ECBOSetTerms procedure is also invoked the first time the user creates UPM.

ECBOSetTerms

[0382] Description

[0383] The first time an UPM is created in the active CBO, the user is first asked to read the UPM terms and conditions (e.g., copyright ownership, etc.). If the user accepts them, the date/time stamp of the acceptance is recorded with the CBO.

[0384] Functional Processing

• [0385] I. Verify that the CBO id passed is valid.
• [0386] II. Set the UPM terms and conditions date/time stamp to the time string passed in the active CBO.

[0387] Parameter List

[0388]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Time string
	Outputs
	Errors	RC_SYSTEM_ERROR

[0389] Index Classes

• • [0390] E_CustomBookOutline
    ECOBOAddUPM

[0391] Description

[0392] This function adds the UPM that a user has entered into the web application into the CBO. ECBOAddUPM validates the designated insert location and stores the UPM with its associated location attributes in the digital library. The UPM title and size are stored within the CBO part. The UPM text is stored in a separate part The UPM is stored as a part whose number is determined by a UPM counter initialized to 50. This function performs the following tasks.

[0393] Functional Processing

• [0394] 1. Verify that the CBO id passed is valid.
• [0395] 2. Verify that the container id passed is valid, if specified.
• [0396] 3. Verify that the UPM id passed is valid, if specified.
• [0397] 4. If the UPM id passed is null, this is a UPM add operation:
  • [0398] a) Create a new UPM with the passed UPM title and text blob as the content. The UPM Title is placed into the CBO part and the content is placed into a new UPM part having a unique identifier defined by the attribute, S_LastUpmPartID which is an incremental counter. S_LastUpmPartID, resides in the E_CustomBookOutline index class and contains the UPM id used in the creation process. Once the UPM is stored within DL, this attribute is incremented.
  • [0399] b) If the container id passed is null or invalid, insert the UPM at the end of the last chapter in the CBO, before any back matter elements in the chapter.
  • [0400] c) If the container id passed is valid, insert the UPM at the end of the container referenced, before any back matter elements in the container.
  • [0401] d) Note that an UPM add operation is always in the context of a container. The UPM can be moved outside the container as needed.
• [0402] 5. If the UPM id passed is not null, this is an UPM update operation.
  • [0403] a) Verify that the UPM does exist in the CBO.
  • [0404] b) Update the content of the UPM with the UPM text blob passed.
  • [0405] c) The location of the UPM remains unchanged.
• [0406] 6. Set the UPM Title attribute in the CBO to the title passed.
• [0407] 7. Volume size management is performed. If an add or update causes the total virtual page count of the current volume to go above or below the volume virtual page count limit, the volumes are reorganized.
• [0408] 8. Pricing and virtual page count calculations are performed for each add or update operation. The net results are stored as attributes for the affected Chapter, Volumes as well as the CBO totals.

[0409] Parameter List

[0410]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Container id
		Title
		UPM id
		UPM text blob
	Outputs	New CBO description
	Errors	RC_NOT_FOUND
		RC_INVALID_CBO
		RC_SYSTEM_ERROR

[0411] After the UPM has been added to the CBO, the user is returned to the CBO screen where he can view the newly added material 164 (see FIG. 15A).

[0412] User-provided material may be edited by clicking on the UPM title, which is a hypertext link to the UPM part. This action invokes the ECBOGetUPM procedure to retrieves the UPM part and display it in editing window 160 of the “My Custom Content” screen (FIG. 14).

ECBOGetUPM

[0413] Description

[0414] This will return the UPM content of an UPM section, including all of the UPM elements.

[0415] Functional Processing

• [0416] I. Verify that the CBO id passed is valid.
• [0417] II. Verify that the UPM id passed is valid.
• [0418] III. Retrieve the content of the UPM.
  • [0419] A. If there is one single element in the UPM, retrieve its content into a text buffer.
  • [0420] B. If there are multiple elements in the UPM, retrieve all their contents in one single text buffer, in the order they appear in the UPM.

[0421] Parameter List

[0422]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		UPM id
	Outputs	UPM text blob
	Errors	RC_SYSTEM_ERROR

[0423] Index Classes

• • [0424] CustomBookOutline
    Once the user has entered his desired changes, he clicks on button 162 and once again invokes the ECBOAddUPM procedure. This time, the procedure recognizes the UPM as an update and follows the alternate processing path described above.

[0425] Adding New Containers to the CBO

[0426] FIG. 15B represents the lower portion of the “My Book Outline” screen, including the “Add” and “Change” sections 124, 126 previously described. We will now assume that the user wishes to add a custom container (i.e., chapter) to the CBO in FIG. 15A. To do so, he enters a desired container title in field 121 and clicks on the “Add” button 124. This action invokes the ECBONewContainer procedure described below.

ECBONewContainer

[0427] Description

[0428] This function will add a new container (e.g. chapter) into the users active CBO. It does not add content to the container.

[0429] Functional Processing

• [0430] I. Verify that the CBO id passed is valid.
• [0431] II. Verify that the container type passed is valid.
• [0432] III. Create a new empty container at the end of the CBO.
• [0433] IV. Set the title attribute to the container title if specified; otherwise set the title to the default.

[0434] Parameter List

[0435]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Container type
		Container title
		Output flag
	Outputs	New CBO description if output flag 0;
		New container id if output flag 1
	Errors	RC_NOT_FOUND
		RC_INVALID_CONTAINER_TYPE

[0436] Index Classes

• • [0437] CustomBookOutline

[0438] The new container 165 is added to the CBO as shown in FIG. 16. We will now assume that the user wishes to rearrange the entities in his CBO.

[0439] Moving and Relocating Content

[0440] There are two separate processes involving the movement of content within a CBO. These processes are: moving and relocating. Moving content involves some piece of content moving up or down by one item within a CBO. Relocation involves moving a piece of content to some other location within the CBO. Sections, UPM and chapters are the only entities permitted to be moved within a CBO. For a movement or relocation task to complete without error, the following rules must be obeyed.

• [0441] 1. A section must reside within a chapter
• [0442] 2. A chapter must reside within a volume
• [0443] 3. UPM must reside within either a chapter or a volume
• [0444] 4. A chapter/UPM is not permitted before a volume's front matter
• [0445] 5. A chapter/UPM is not permitted after a volume's back matter
• [0446] 6. A section is not permitted before a chapter's front matter
• [0447] 7. A section is not permitted after a chapter's back matter
• [0448] 8. All content must move/relocate without error, or none of the content is moved/relocated.

[0449] Content is moved within a CBO via the “My Book Outline” display screen (see FIG. 16). A user selects the content to be moved by checking its corresponding select box. In the present example, section 1.3 has been selected 166. He then specifies a target location using drop down box 168. Within the box the user may select to move an entity up or down (by one of the same entity), select an existing chapter from a current list of chapter titles, or create a new untitled chapter. In the present example, the user has selected to move section 1.3 to existing Chapter 4. After selection, the user clicks on the “Move Items” button 170.

[0450] If the user selects to move content up or down, the ECBOMoveContent function is invoked. If he selects to move content to a different chapter or a new chapter, the ECBORelocateContent function is invoked. Both functions are described below. Both procedures cause page and price totals to be recalculated and stored in digital library via the EAdminPopulatePageAndPrice procedure, also described below.

ECBOMoveContent

[0451] Description

[0452] This function will move content up and down within the CBO per the instructors' direction. This function permits moving one or more pieces of similar content in the same call. Similar content is defined to be either all sections and UPM's or all chapters, but not hybrids of the two. It will make sure that all rules are adhered to and will also request Volume Size Management when necessary.

[0453] Functional Processing

• [0454] 1. Verify that the CBO id passed is valid.
• [0455] 2. Verify that selected content is either all chapter containers or all sections, but not a mixture of both.
• [0456] 3. Contents listed are moved one at a time. For moving up, the contents are processed in the order listed. For moving down, the contents are processed in the reverse order.
• [0457] 4. Verify that the piece of content does exist in the CBO.
• [0458] 5. Verify that the piece of content is not a front or back matter element. Front or back matter elements can only be moved implicitly when an entire chapter is moved.
• [0459] 6. When moving containers down (e.g. Chapter):
  • [0460] a) Verify that after this piece of container content in the CBO, there is at least one more piece of content at the same level (e.g. Chapter, UPM Section outside a chapter).
  • [0461] b) Move the piece of container content to the position after that next piece of content.
• [0462] 7. When moving content components Sections down:
  • [0463] a) If it is the last section besides any back matter elements in a chapter, verify that chapter is not the last chapter in the CBO.
  • [0464] b) Move the piece of content down by one position, but skip over any front or back matter elements. If leaving a chapter, it is moved to the beginning of the next chapter.
• [0465] 8. When moving content component UPM Sections down:
  • [0466] a) If i is outside chapters, verify that it is not the very last element in the CBO.
  • [0467] b) Move the piece of content down by one position, but skip over any front or back matter elements. If leaving a chapter, move it to the position immediately after the chapter thus at the same level as a chapter. H entering a chapter, move it after any lead front matter in the chapter.
• [0468] 9. When moving containers up:
  • [0469] a) Verify that before this piece of container content in the CBO, there is at least one more piece of content prior to it at the same level (e.g. Chapter, UPM Section outside a chapter).
  • [0470] b) Move the piece of container content to the position before that previous piece of content.
• [0471] 10. When moving content components up:
  • [0472] a) If it is the first section besides any front matter elements in a chapter, verify that chapter is not the first chapter in the CBO.
  • [0473] b) Move the piece of content up by one position, but skip over any front or back mater elements. If leaving a chapter, it is moved to the end of the previous chapter.
• [0474] 11. When moving content component UPM Sections up:
  • [0475] a) If it is outside chapters, verify that it is not the very first element in the CBO.
  • [0476] b) Move the piece of content up by one position, but skip over any front or back mater elements. If leaving a chapter, it is moved to the position immediately before the chapter thus at the same level as a chapter. If entering a chapter, move it before any trailing back matter in the chapter.
    • [0477] If a move causes the total virtual page count of the current volume to go above or below the volume virtual page count limit, the volumes are reorganized.
• [0478] 12. Pricing and virtual page count calculations (described subsequently) are performed for each move operation and stored in digital library via the EAdminPopulatePageAndPrice procedure. The net results are stored as attributes for the affected Chapters, Volumes as well as the CBO totals.

[0479] Parameter List

[0480]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Content id list
		Content id count
		Container flag
		Move flag
	Outputs	New CBO description if OK;
		Offending content ids if error
	Errors	RC_NOT_FOUND
		RC_INVALID_CBO
		RC_INVALID_MOVE

[0481] Index Classes

• • [0482] CustomBookOutline
    ECBORelocateContent

[0483] Description

[0484] This will relocate content to a specific location within the same CBO that was specified by the instructor. It is different than a move, which moves content one position at a time, yet it adheres to the same rules and has much of the same processing.

[0485] Functional Processing

• [0486] 1. Verify that the CBO id passed is valid.
• [0487] 2. Verity that the destination container id passed exists in the CBO.
• [0488] 3. Contents listed are relocated one at a time in the order provided.
• [0489] 4. Verity that the piece of content does exist in the CBO.
• [0490] 5. For content containers (e.g. Chapter), add it after the container specified.
• [0491] 6. For content components (e.g. Section, UPM Section), add it to the end of the container specified, before any back matter elements in that container.
  • [0492] If a relocate causes the total virtual page count of the current volume to go above or below the volume virtual page count limit, the volumes are reorganized.
• [0493] 7. Pricing and virtual page count calculations (described subsequently) are performed for each relocate operation. The net results are stored in the digital library via the EAdminPopulatePageAndPrice function as attributes for the affected Chapters, Volumes as well as the CBO totals.

[0494] Parameter List

[0495]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Content id list
		Content id count
		Container id
	Outputs	New CBO description if OK;
		Offending content ids if error
	Errors	RC_NOT_FOUND
		RC_INVALID_CBO

[0496] Index Classes

• • [0497] CustomBookOutline
    EAdminPopulatePageAndPrice

[0498] Description

[0499] Calculate and update the pricing and virtual page count information of either an existing prepublished content product or a CBO. For prepublished content products, this function is called at load time. For CBO's, it is called every time a CBO is modified in a manner affects the CBO page count or price.

[0500] Functional Processing

• [0501] I. Import content of the input filename, which is description of either one existing prepublished content product or one CBO.
• [0502] II. Retrieve the program-specific attributes related to pricing and virtual page count.
• [0503] III. Calculate and update the pricing and virtual page count information for each level of entities in the prepublished content product or CBO description.
• [0504] IV. Export the updated description as content of the output filename.

[0505] Parameter List

[0506]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Input filename
		Output filename
	Outputs	(Content of the output file
		named)
	Errors	RC_SYSTEM_ERROR

[0507] Index Classes

• • [0508] Program
  • [0509] ProgramAux

[0510] In the present example, “General Netiquette” section 1.3 166 is relocated to Chapter 4 by the ECBORelocateContent procedure, as shown in FIG. 17. Affected sections have been renumbered.

[0511] Deleting Content From a CBO

[0512] Content may be deleted from the custom book outline by checking the select box next to the entity to be deleted and then clicking on the “Remove” button 172 on the vertical menu bar (see FIG. 16). This action invokes the ECBORemoveContent procedure, described below.

ECBORemoveContent

[0513] Description

[0514] This will remove content from an active CBO. It After the instructor selects sections/chapters in his active CBO, he may remove them from the CBO. It also will ensure that no content is removed that is a prerequisite to another. It will merge content back into a single volume if possible.

[0515] Functional Processing

• [0516] 1. Verify that the CBO id passed is valid.
• [0517] 2. Content comes in two categories, containers and non-containers. Selected content must be either all containers or all content components, but not a mixture of both.
• [0518] 3. Contents listed are removed one at a time from the active CBO.
• [0519] 4. Verify that the piece of content does exist in the CBO.
• [0520] 5. Verify that the piece of content is not a pre-requisite of any contents in the CBO, other than those being removed this time.
• [0521] 6. Remove the piece of content from the CBO.
• [0522] 7. If a remove causes the total virtual page count of the current volume to go below the volume virtual page count limit, check whether it is possible to move some or all its content elements to the previous volume. If after the adjustment the current volume becomes empty, the current volume is deleted. If subsequent removes cause the total virtual page count of the current volume to go below the volume virtual page count limit, further adjustments are made as needed.
• [0523] 8. Pricing and virtual page count calculations are performed for each remove operation. The net results are stored as attributes for the affected Chapter, Volumes as well as the CBO totals.

[0524] Parameter List

[0525]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
		Container flag
		Content id list
		Content id count
	Outpu	New CBO description if OK;
	ts	Offending content ids if error
	Errors	RC_NOT_FOUND
		RC_PREREQ_ERROR
		RC_INVALID_CBO

[0526] Index Classes

• • [0527] CustomBookOutline

[0528] Certain entities can be protected from deletion. In the present example, these include automatically generated components such as the Table of Contents, Preface, and Index. They also include front and back matter associated with the content sections inserted by the user. Consequently, these entities are not provided with select boxes.

[0529] A user may clear all contents of an active CBO by clicking on the “Clear Book” button 178. This action invokes a simplified version of the previous function, which essentially selects all entities, including front and back matter, UPM's and titles, and removes them from the CBO. The actual implementation is a call to the ECBODelete function, followed by a call to the ECBOCreate function. The user is left with an empty CBO shell like that of FIG. 10A.

ECBODelete

[0530] Description

[0531] This function discards all contents of an active CBO.

[0532] Functional Processing

• [0533] 1. Verify that the CBO id passed is valid.
• [0534] 2. Remove the CBO entirely from the datastore.

[0535] Parameter List

[0536]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
	Outputs
	Errors	RC_SYSTEM_ERROR

[0537] Index Classes

• • [0538] CustomBookOutline

[0539] Undoing Changes to CBO

[0540] With some exceptions, a user may undo the last change to the content of his active CBO. Referring to FIG. 17, this is accomplished by clicking on the “Undo Last” button, which invokes the ECBOUndo procedure described below.

ECBOUndo

[0541] Description

[0542] This function undoes the last change to the content of the active CBO. Note that this is a single level undo capability.

[0543] For each CBO, two versions of the CBO content are maintained as separate parts in the digital library. As each CBO operation is performed, if the operation will change the content of the CBO, the active version before the change is saved as the backup version. And the new active version will include the change. Later on when the undo operation is required, the backup version is restored into the active one.

[0544] Functional Processing

• [0545] I. Verify that the CBO id passed is valid.
• [0546] II. Verify that the active version of the CBO is available.
• [0547] III. Verify that the backup version of the CBO is available.
• [0548] IV. Set the Undoable status to False in the backup version.
• [0549] V. Mark the backup version as the new active version of the CBO.
• [0550] VI. Remove the old obsolete active version of the CBO.
• [0551] VII. The following CBO operations can be undone:
  • [0552] A. ECBOAddContent
  • [0553] B. ECBONewContainer
  • [0554] C. ECBORemoveContent
  • [0555] D. ECBOMoveContent
  • [0556] E. ECBORelocateContent
  • [0557] F. ECBOSetTitle
  • [0558] G. ECBOSetState
  • [0559] H. ECBOSetTerms
• [0560] VIII. The following CBO operations cannot be undone:
  • [0561] A. ECBOCreate
  • [0562] B. ECBODelete
  • [0563] C. ECBOUndo
  • [0564] D. ECBOAddUPM
  • [0565] E. ECBOSubmit
• [0566] IX. The following CBO operations have no impact on the undoable status since there was no change to the CBO:
  • [0567] A. ECBOGet
  • [0568] B. ECBOList
  • [0569] C. ECBOListByCreator
  • [0570] D. ECBOGetUPM

[0571] Parameter List

[0572]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		CBO id
	Outputs	New CBO description
	Errors	RC_CBO_NOT_UNDOABLE
		RC_SYSTEM_ERROR

[0573] Index Classes

• • [0574] CustomBookOutline
  • [0575] Editing an Existing CBO

[0576] Returning users may already have CBO's stored in the digital library 20 that were created in previous sessions. Thus at logon, the logon procedure invokes the ECBOListByCreator procedure, which issues a query to the digital library 20 to find any CBO entries in which the E_CreatorID column matches the userid. The ECBOListByCreator function is described below.

ECBOListByCreator

[0577] Description

[0578] This will return a list of CBO's created by a particular user within a Program ID.

[0579] Functional Processing

• [0580] 1. Verify that program id passed is valid.
• [0581] 2. Search for CBO's with the program id and the creator id specified.
• [0582] 3. For each CBO found, output the CBO id, Type, Title, Creator id, Modification timestamp, and CBO status.

[0583] Parameter List

[0584]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Program id
		Creator id
	Outputs	CBO id list
	Errors	RC_INVALID_OR_MISSING_INPUT
		RC_SYSTEM_ERROR

[0585] Index Classes

• • [0586] CustomBookOutline
  • [0587] Program

[0588] FIG. 9B is an example of a welcome screen that may be presented to a returning user by the ECBO ListByCreator procedure. The Custom Book Outlines section 113 lists CBO's that the user created in previous sessions.

[0589] The user now has three options. He may 1) select an active CBO for modification by clicking on its title, 2) “CLONE” and modify an existing CBO by clicking on the CBO's corresponding CLONE button 116, or 3) create a new CBO by clicking on button 118

[0590] To modify an existing CBO, the user clicks on its title. This action invokes the EDIT procedure, which retrieves the corresponding CBO and associated parts from digital library 20 (but not the actual content). The CBO is parsed and displayed to the user in the same format previously described with reference to editing a new CBO. In this case, however, there will already be entities present in the outline. The user may now add, move, or delete content as previously described.

[0591] The user may wish to create a new version of a CBO while preserving the original CBO. This can be achieved by invoking a “CLONE” function. In brief, the “CLONE” function makes a duplicate copy of an existing CBO which the user may then modify as desired. The user merely clicks on the “CLONE” button 116 corresponding to the CBO to be copied. This action invokes the ECBOClone procedure described below.

ECBOClone

[0592] Description

[0593] This function will copy an existing CBO to a new CBO for a user. It copies all UPM and pre-published material contained within the CBO. Users clone CBO's when then they.

• [0594] I. Click on the Clone button within the Login page
• [0595] II. Click on the Clone button within the MyBookOutline page

[0596] Functional Processing

• [0597] I. Copy the existing CBO to a new CBO with users userid and title specified.
• [0598] II. Mark the new CBO's status as Working (CBO Status=“1”).
• [0599] III. Extract the Program variables related to pricing and virtual page count, storing them in the CBO. The estimated page count and prices from the original CBO are kept on the new CBO.
• [0600] IV. Writes the CBO to the digital library

[0601] Parameter List

[0602]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Program id
		Userid
		Existing CBO id
		New CBO Title
	Outputs	New CBO id
	Errors	RC_INVALID_OR_MISSING_INP
		UT
		RC_SYSTEM_ERROR

[0603] Index Classes

• • [0604] CustomBookOutline
  • [0605] Program
  • [0606] ProgramAux

[0607] Viewing a CBO

[0608] When the user has completed creating his custom book outline, he may view its contents by clicking on “Submit Request” button 180 on the vertical menu bar (see FIG. 16). This action invokes View procedure in application layer 28. Briefly, the view procedure displays the custom book in a manner as shown in FIG. 18, i.e., in a table of contents format wherein the section titles are hypertext links 190 to files containing the actual section content files retrieved. By clicking on any section title, the user invokes the EGetHTML procedure. In brief, the EGetHTML procedure retrieves the part containing the SGML contents of the selected section and passes them to an SGML to HTML converter. An example of an SGML to HTML converter suitable for use according to the present embodiment is the publicly available Omnimark Konstructor. The SGML to HTML converter performs the conversion using a data type dictionary, which defines the SGML content. The EGetHTML procedure is described in more detail below.

EGetHTML

[0609] Description

[0610] This function retrieves the SGML content for a particular sequence id and then passes the content blob to an SGML to HTML converter (e.g., Konstructor). Search words are also passed so that the converter can highlight found words. It communicates over a TCP socket to Konstructor.

[0611] The low resolution associated components for all sections are stored on the front-end web server for fast retrieval on presentation. Therefore, the content does not have to make a digital library call for each image, speeding up retrieval.

[0612] Functional Processing

• [0613] I. Construct the header that contains tags for the sequence id, title hit words and index hit words.
• [0614] II. Search for a product entity with the sequence id passed.
• [0615] II. Retrieve the SGML part of this entity.
• [0616] IV. Connect to the Konstructor server using the SGML hostname/IP address and port number passed.
• [0617] V. Send the header information that contains tags for the sequence id, title hit words and index hit words.
• [0618] VI. Send the SGML data for translation.
• [0619] VII. Receive from the Konstructor server the HTML blob resulted from the translation.
• [0620] VIII. Disconnect from the Konstructor server.

[0621] Parameter List

[0622]

	Inputs	DSUsername
		DSPassword
		DSHostname
		Userid
		SGML hostname or IP
		address
		SGML port number
		Sequence id
		Title hit words
		Index hit words
	Outputs	HTML blob
	Errors	RC_SYSTEM_ERROR
		−1

[0623] Index Classes

• • [0624] Product

[0625] 4. Page and Price Calculation

[0626] The Page and Price calculations are performed by EProductGetOutline and the CBO routines using a set of algorithms against data that is stored in the digital library in both the Program and Section entities. This estimated page count and price can be overridden with actual page counts from the original pre-published sections by system administrators.

Inputs

[0627]

CBO	UPMBYTES	Derived number of bytes of UPM in the CBO
E_Program	AvgChrPerImage	Average characters per image
	AvgChrPerSGMLAC	Average characters per SGML Associated Component
	MaxChrPerUpmTier	Number of characters in an UPM pricing block
E_ProgramAux	PE_Base_Cust_Pub_Price	Base price to be added to every custom publication
	PE_Base_UPM_Fee	Base price to be added whenever UPM is included
	PE_Incr_UPM_Fee	Additional price for each UPM pricing block
	PE_Source_Price_Per_Page	Price per page for pre-published content included
	PE_UPM_Bytes_Per_Page	Number of UPM characters in a page
	PE_Minimum_Page_Limit	The minimum number of pages required in a custom publ.
	PE_Volume_Page_Limit	The maximum number of pages in a volume
	PE_AC_Form_ID	The associated component type defined in
	PE_AC_ByteCount	Number of “characters” for that associated component type
E_Product	Image_Type	Type of image, as defined in
	Image_Type	Number of non-markup characters in content
	AC_ImageCount	Number of associated component images in content
	ACSubdocCount	Number of SGML subdocuments in content
	PageCount	Actual page count of content
E_ProductAux	AC_Counts.ACFORMID	The associated component type defined in
	AC_Counts.NUMBERAC	The number for each associated component type
	Use_Actuals	Switch to determine if content actual page count is used

Outputs

[0628] None.

[0629] It is desirable to construct a page and price calculator for the purpose of estimating page and pricing information for a CBO. The following page and price calculator described below was devised for this purpose. Each time the ECBOGet function is called to retrieve a CBO for displaying, the Page and Price calculation routines are run for the CBO.

[0630] Actual Page and Price calculations occur several times throughout the life of a CBO, e.g., Page and Price calculations for Chapters, Volumes and the entire CBO occur any time there is an operation performed on that CBO which includes adding, moving, or deleting content. For pricing consistency the Page and Price calculation for a pre-published section in the present embodiment occurs one and only one time for the entire life of that content inside the CBO. However, it will be understood that a system designer can alternatively decide to permit changes to prepublished sections if desired.

[0631] The price of a CBO is dependent on the page count. Therefore, the page count is calculated first. According to the present embodiment, the Chapter Page Count calculation is the aggregation of the Section and UPM Page Counts for any content that exists in that chapter. The Chapter Price calculation is the aggregation of only the Section Prices for any sections that exist in that chapter. Calculation of the Pages for volumes is the aggregation of the Chapter and UPM Page Counts for all chapters in that volume and UPM that exist as a direct child of that Volume. The Volume Price calculation is the aggregation of only the Chapter Prices for any Chapters that exist in that volume. Calculation of the Page Counts for the entire CBO is the aggregation of all of the Volume Page Counts. Price calculations for the CBO are done with the Volume Page Counts, Total UPM Page Count, Volume Prices, and the specific program variables as inputs into the CBO price calculation formula. This embodiment implies the following page count calculation order:

• [0632] 1. Section/UPM Page Count
• [0633] 2. Chapter/UPM Page Count
• [0634] 3. Volume Page Count
• [0635] 4. Book Page Count

[0636] A section's page counts are estimated based upon the number of non-tag characters in the content, plus the number and type of associated components (AC). AC's are graphics appearing in the section and cannot exist outside of the section. In an effort to make the page estimating process more accurate, AC's are broken up into five different categories based on size. The categories below are differentiated and their values stored in the ProgramAux index class and their values stored in PE_AC_ByteCount. The E_ProductAux index class will then contain matching ACFORMIDs and NUMBERAC values to use in the calculation. Page counts will be rounded to the nearest tenth of a page.

[0637]

1Associated Component Categories
	1	Inline Graphic
	2	Display Graphic
	3	Inline Equation
	4	Display Equation
	5	SGML

[0638] In some cases, the automated page/price calculator does not prove to be accurate to the original pre-published material's figures. Therefore, a Use_Actuals option is provided within the calculator. This option provides the system administrator with the capability to override a calculated value for the page and/or price values for a pre-published content. This Use_Actuals capability forms the beginning of the calculator process.

Page and Price Count Calculator Process

• [0639] 1. When Use_Actuals is “1” and PageCount has a value, then use PageCount
• [0640] 2. When Use_Actuals is “0” or PageCount has no value, then use the calculation below.
  • [0641] a) First, calculate the number of “characters” in the content, using textual SGML, images, graphics, and subdocument SGML. These values are preferably calculated by Converter 10 and are loaded by the Eloader program. The calculator then multiplies the number of each category of associated component by the average byte count for each category and then adds the number of source characters (Char_Count) in the SGML. Char_Count is stored within the Product Index Class.
    Characters=(E_Char_Count+Σ^{1−n (NumberAC×PE—AC—ByteCount)}

[0642] Equation 2. Characters Per Page Calculation

• • [0643] b) Second, divide the number of “characters” by the average number of “characters” per page (AvgCharPerPage) to get the estimated page count. The AvgCharPerPage variable is stored within the Program index class and placed within the CBO at CBO create time.
    Pages=Characters/E_AvgChrPerPage

[0644] Equation 3. Estimated Pre-published Pages Calculation

[0645] 3. Calculate the UPM Estimated Page Count by dividing the number of UPM characters (UPMBytes) by the number of UPM characters per page (PE_UPM_Bytes_Per_Page). The UPMBytes is the UPM file size and is computed when the UPM is added to the CBO and stored into the CBO. The PE_UPM_Bytes_Per_Page variable is stored within the E_ProgramAux index class and placed within the CBO at CBO create time.
UPM Page Count=UPMBytes/PE_UPM_Bytes_Per_Page

[0646] Equation 4. UPM Page Count Calculation

[0647] Once the page count is computed, the pricing information can be derived. Pre-published content pricing is determined by first multiplying the estimated page count with the price per page value.
Estimated Price=Pages×PE_Source_Price_Per_Page

[0648] Equation 5. Estimated Base Price Calculation

[0649] Note that UPM pricing is calculated at the CBO level. Therefore, the price for an UPM Section is never calculated. However, the UPM Section Page Counts are calculated every time the CBO Page and Prices are calculated.

[0650] Next, the UPM cost is calculated and added to make a total publication cost. The UPM calculation is based on a base charge for all books containing UPM content. This base charge is the minimum cost added to a book containing UPM.

[0651] If a CBO contains UPM then the UPM estimated page count (UPM_Page_Count) is used to select the equation to be used. When the UPM Page Count is greater than the UPM Base Size (PE_Chars_Per_UPM_Tier) perform the calculation in Equation 5. Otherwise, use the calculation in Equation 6. PE_Chars_Per_UPM_Tier is stored within the Program Index Class and stored within the CBO at creation time.

[0652] Use the greater of the minimum CBO cost (PE_Min_Order_Price) and the CBO Estimated Price.
If UPMBytes>0, then UPM_Base_Charge=PE_Base_UPM_Fee; otherwise UPM_Base_Charge=0;
CBO Estimated Price=PE_Base_Cust_Pub_Price+
Σ¹⁻ⁿ ((Pages)×PE_Source_Price_Per_Page+PE_Base_UPM_Fee+
((UPMBytes−PE_Chars_Per
—UPM_Tier)/PE_UPM_Bytes_Per_Page)×PE Incr_UPM−^Fee
Equation 6. Estimated Price Calculation with UPM Greater than Base
If UPMBytes>0, then UPM_Base_Charge=PE_Base_UPM_Fee; otherwise
UPM_Base_Charge=0;
CBO Estimated Price=PE_Base_Cust_Pub_Price+Σ¹⁻ⁿ (Pages)+PE
—Base_UPM_Fee
Equation 67. Estimated Price Calculation with UPM Less than Base

[0653] The Page and Price count example consists of a Custom Book Outline (CBO) entitled Student Loans. Referring to FIG. 19, two pre-published sections 201, 202 are added to the CBO resulting in the HTML table of contents view shown.

[0654] In the above example, the ECBOGet function was called at the conclusion of adding the two pre-published sections (ECBOAddContent). The CBO calculations are shown below.
Section 1.1 Characters=(40+(2×50)+(3×10))=170
Section 1.1 Pages=170/290=0.0586=0.06 rounded  (203)
Section 1.1 Estimated Price=0.586×10=0.0586=0.06 rounded  (204)
Section 1.2 Characters=(70+(3×50)+(7×10))=290
Section 1.2 Pages=290/290=1.0  (205)
Section 1.2 Estimated Prices 1.0×0.10=0.1  (206)

[0655] After calculating the newly added section page and prices, the chapter's page and price calculations can be performed. This consists of the summation of it's contents. For chapter one the calculation is:
Chapter 1 Pages 0.6+1.0=1.6
Chapter 1 Estimated Price=0.06+0.1=0.16

[0656] Next, the volume page and price is calculated by summing the chapter values and adding the cost associated with the front matter and back matter (i.e. index). In this case, volume 1 contains only one chapter, 1. The page and price counts for the volume are shown below. It assumes the page and costs of the front and back matter are: 15 and 5 respectively.
Volume 1 Pages=1.6+15+5=21.6  (207)
Volume 1 Estimated Price=0.16+1.5+0.5=2.16  (208)

[0657] Lastly, the book's values are calculated by summing all the volume values. In this case, there is only one volume. The book's values are therefore the same as the Volume 1 page count and estimated price.

[0658] 5. Volume Boundaries Determination

[0659] One of the inherent properties of a CBO is a maximum number of pages allowed to exist in a Volume. This volume page count limitation is retrieved from the ProgramAux index class and stored into the CBO when it is created. It is that value, stored in the CBO, that is used to define the volume boundaries for the life of that CBO. Several operations that the user can perform, including moving, relocating, adding, and deleting content, will create a need for the volume page counts for that CBO to be examined. Alterations to the layout of the volumes to accommodate Page Limits will occur automatically by this routine with the following conditions:

• • [0660] 1) All changes to volumes are done with a move up or move down.
  • [0661] 2) Added/Updated UPM can never have a higher page count than the Volume Page Limit
  • [0662] 3) Added/Updated Chapters can never have a higher page count than the Volume Page Limit
  • [0663] 4) If a Chapter is moved from one Volume to another, the Chapter is moved in its entirety. No “Chapter Splitting” is permitted.
  • [0664] 5) After content is moved from one volume to another, the sequential order of content in the table of contents for the CBO should be exactly as before the move occurred.
  • [0665] 6) A new volume is created if a volume page limit is exceeded and there are no volumes below that volume in which to move the exceeding content.
  • [0666] 7) Content can be moved up if there is enough space created in a preceding volume to fit the first piece of content from the next volume.
  • [0667] 8) If a volume no longer contains any content, it is removed.
    ReorganizeCBO Routine

[0668] The reorganizeCBO routine is an internal function not defined in the API layer. It is used by other public functions (i.e. ECBOAddUPM, etc.) to facilitate volume management. This routine is responsible for managing the volume page limits of a CBO. This routine accomplishes this task in the following steps:

• • [0669] 1) Retrieve this CBO's volume page limit from inside the CBO
  • [0670] 2) For each volume in the CBO do the following:
    • [0671] a) Calculate the number of pages in a volume X
    • [0672] b) If the number of pages in volume X is greater than the limit
      • [0673] i) Find the last piece of content in volume X
      • [0674] ii) Make sure the size of the last piece of content is less than the Volume Page Limit
      • [0675] iii) Get the next volume, X+1, in the system, or create a new one if there isn't one
      • [0676] iv) Place the last piece of content at the head of volume, X+1
      • [0677] v) recalculate the page counts for volume X and X+1
      • [0678] vi) Re-call (a.k.a. recursion) the reorganizeCBO routine from the beginning to see if moving the last piece of content from volume X+1 to volume X has balanced everything out.
    • [0679] a) Check to see if volume X−1 has enough space to move the first piece of content from volume X up into volume X−1. If volume X−1 does not exist, this step and substeps are skipped.
      • [0680] i) Place the first piece of content from volume X at the end of volume X−1
      • [0681] ii) Recalculate the page counts for both volume X−1 and X
      • [0682] iii) Re-call (a.k.a. recursion) the reorganizeCBO routine from the beginning to see if moving the first piece of content up a volume has balanced everything out.
    • [0683] a) Check to see if the volume X is empty. If so, it can be deleted.
    • [0684] b) Recalculate the page and prices for the entire CBO and then go back to step a) using the next volume in the CBO. When all volumes make it through step e) the CBO is balanced and the pages and prices for the CBO have been recalculated and the routine is finished.