admin/include/scribe_application.php

<?php
/**********************************************************
Function Library: scribe_application.php
Original Author: Paul Bramscher <brams006@umn.edu>
Last Modified: 03.16.2004
***********************************************************
Comments:
This library brings together all of the SQL actions in
the CLPS system.  Note that it occasionally relies
on app_controls.php and other libraries as well, but these
are specific to CLPS.
***********************************************************
Table of Contents:
assignPageStaff
assignStaffCoordinator
copyPasteElement
deleteCopyBuffer
deleteCoursePers
deleteElement
deletePage
deletePageConfirm
deletePageStaff
displayTOC
elementDown
elementMultiFormat
elementSize
elementUp
getMaxIndent
insertCoursePers
insertScribeLabel
insertScribeLocation
insertScribeResource
insertScribeRQS
insertScribeRQSLink
insertScribeService
insertScribeStaff
pageLoadStats
pageTemplate
pageTemplateConfirm
parentIs
parentProbe
pasteElement
populateGenArray
scribePublish
scribeUnpublish
sibProbeElder
sibProbeYounger
toggleTOCDisplay
toggleTOCWrap
toggleURLDisplay
toggleUpDisplay
toggleUpText
updatePageDebug
updatePageHeader
updatePageTitleStyle
updateScribeCourse
updateScribeCourseConcat
updateScribeElement
updateScribeHeader
updateScribeStyle
updateScribeUpdate
youngerProbe
**********************************************************/


/**********************************************************
Function: assignPageStaff
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Assigns staffpersons (possibly multiple) to a given page
and calls the page edit mode back again.
**********************************************************/
function assignPageStaff($page_id, $staff_id_array) {

        // For all staff in the array
        for ($subscript = 0; $subscript < sizeof($staff_id_array); $subscript++ ) {
        
                // Check to make sure that the staff isn't already assigned
                $sql = "SELECT * FROM page_staff where page_id = " . $page_id .
                " AND staff_id = " . $staff_id_array[$subscript];
                $rs = xx_tryquery($sql);
                if (xx_num_rows($rs) == 0) {

                        $sql = "INSERT INTO page_staff (page_id, staff_id) VALUES ("
                                . $page_id
                                . ", "
                                . $staff_id_array[$subscript]
                                . ")";                  
                        xx_tryquery($sql);
                        
                } // staff not already assigned

        } // array of staff id's

        // Call the PageScribe back
        header("Location: scribe.phtml?page_id=" . $page_id . "&cmd=pagestaff");

} // function


/**********************************************************
Function: assignStaffCoordinator
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Assigns a single staff coordinator to a given page and
calls the page edit mode back again.
**********************************************************/
function assignStaffCoordinator($page_id, $staff_coordinator) {

        $sql = "UPDATE page SET staff_coordinator = "
                . $staff_coordinator
                . " WHERE page_id = "
                . $page_id;
                
        xx_tryquery ($sql);
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: copyPasteElement
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Copies the supplied element id and descendants (if picked)
and inserts them into the user's copy/paste buffer.  Any
previously copied data is replaced.
**********************************************************/
function copyPasteElement($page_id, $place_array_HTML, $copysingle, $sess_staff_id){

        // Split by comma separated values
        $place_array = split(",", $place_array_HTML);

        // Break apart place array
        $element_id = $place_array[0];
        $element_order = $place_array[1];
        $indent_level = $place_array[2];
        $parent_id = $place_array[3];
        $position = $place_array[4];
        
        // First, we delete any previously cut elements from the pastebuffer table
        $sql = "DELETE FROM pastebuffer WHERE paste_staff_id = "
                . $sess_staff_id;
        xx_tryquery($sql);

        // Element is a parent, and user is copying that element only.
        if ($copysingle == 1) {
                $end_element_order = $element_order;
        
        }

        // Copy parent and all descendants.  Determine the block of affected rows       
        else {
        
                // End order flags
                $end_found = 0;
                $end_element_order = $element_order;
                $last_element_order = $element_order;

                $sql = "SELECT element_id, indent_level, element_order FROM element where page_id = "
                        . $page_id
                        . " AND element_order > "
                        . $element_order
                        . " ORDER BY element_order";
                $rs = xx_tryquery($sql);

                // Check for indent level
                while (($row = xx_fetch_array ($rs, xx_ASSOC)) && ($end_found == 0)) {

                        $probe_element_id = $row["element_id"];
                        $probe_indent_level = $row["indent_level"];
                        $probe_element_order = $row["element_order"];

                        if ($probe_indent_level <= $indent_level) {
                                $end_element_order = $last_element_order;
                                $end_found = 1;
                        }
                        else $end_element_order = $probe_element_order;
                        $last_element_order = $probe_element_order;             
                        //printf("probed element: %d<BR>", $probe_element_id);
                        //printf("probed indent: %d<BR>", $probe_indent_level);

                } // end of affected elements to copy

        } // determine last descendant to copy
        
        /*
        Select the block of affected elements and insert them into the pastebuffer table
        */
        $sql = "INSERT INTO pastebuffer (
                paste_staff_id,
                parent_id,
                resource_id,
                location_id,
                service_id,
                staff_id,
                subject_id,
                indent_level,
                label,
                label_url,
                element_descr,
                element_size,
                element_order)
                SELECT
                staff.staff_id AS paste_staff_id,
                parent_id,
                resource_id,
                location_id,
                service_id,
                element.staff_id,
                subject_id,
                indent_level,
                label,
                label_url,
                element_descr,
                element_size,
                element_order
                FROM element, staff
                WHERE staff.staff_id = "
                . $sess_staff_id
                . " AND page_id = "
                . $page_id
                . " AND element_order >="
                . $element_order
                . " AND element_order <="
                . $end_element_order
                . " ORDER BY element_order";

        xx_tryquery($sql);      
        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 
        
} // end function


/**********************************************************
Function: deleteCopyBuffer
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Clears the user's copy/paste buffer.
**********************************************************/
function deleteCopyBuffer($page_id, $paste_staff_id){

        $sql = "DELETE from pastebuffer WHERE paste_staff_id = "
                . $paste_staff_id;
        xx_tryquery($sql);
        header("Location: scribe.phtml?page_id=". $page_id);
}


/**********************************************************
Function: deleteCoursePers
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Deletes the supplied personnel id from the course.
**********************************************************/
function deleteCoursePers($course_id, $page_id, $personnel_id){

        // Build the sql.
        $sql = "DELETE from course_personnel WHERE personnel_id = "
                . $personnel_id
                . " AND course_id = "
                . $course_id;
        xx_tryquery($sql);
        header("Location: scribe.phtml?page_id=". $page_id);
}


/**********************************************************
Function: deleteElement
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Deletes the supplied element id.  Depending on user selection,
all descendants are also deleted, or else promoted to the
generation of the deleted parent.

This function also deletes references to the affected element,
and any removed descendants, from the libstats statistics
table.
**********************************************************/
function deleteElement($page_id, $place_array_HTML, $promote){

        // Split by comma separated values
        $place_array = split(",", $place_array_HTML);

        // Break apart place array
        $element_id = $place_array[0];
        $element_order = $place_array[1];
        $indent_level = $place_array[2];
        $parent_id = $place_array[3];
        $position = $place_array[4];


        /* Incoming promote parameters
        0: no children
        1: children present, promote them
        2: children present, delete them
        */


        /********************************************************
        ** Item is singular, no children.  Simple delete case. **
        ********************************************************/
        
        if ($promote == 0) {
                
                // First delete the element
                $sql = "DELETE from element WHERE page_id = "
                        . $page_id
                        . " AND element_id = "
                        . $element_id;
                xx_tryquery($sql);
                
                // Next, update the order of the remainders
                $sql = "UPDATE element SET element_order = element_order - 1 WHERE page_id = "
                        . $page_id
                        . " AND element_order > "
                        . $element_order;
                xx_tryquery($sql);

                // Last, delete the element reference from the stats database
                $sql = "DELETE from libstats.elementstats WHERE page_id = "
                        . $page_id
                        . " AND element_id = "
                        . $element_id;
                xx_tryquery($sql);

                // Done, return to page
                if ($position > 2) $new_pos = $position - 1;
                else $new_pos = 1;
                header("Location: scribe.phtml?page_id=". $page_id . "#p" . $new_pos);
        
        } // end simple delete


        /*************************************
        ** Delete element, promote children **
        *************************************/

        else if ($promote == 1) {
        
                // Success flag
                $success = 1;
                
                // Intialize first descendant indent level to proper value
                $desc_indent_level = $indent_level + 1;                 

                /*
                First, we need to march through the records, starting at the
                first child.  We need to decrease all indent levels by one.  When
                we arrive at an indent level equal to the parent's, it is a sibling
                (of the parent) and we stop.
                */

                $sql = "SELECT element_id, parent_id, indent_level, element_order FROM element WHERE page_id = "
                        . $page_id
                        . " AND element_order > "
                        . $element_order
                        . " ORDER BY element_order";
                $rs = xx_tryquery($sql);

                // Check for and promote all descendants
                while (($row = xx_fetch_array ($rs, xx_ASSOC)) && ($desc_indent_level > $indent_level)) {
                        $desc_element_id = $row["element_id"];
                        $desc_parent_id = $row["parent_id"];
                        $desc_indent_level = $row["indent_level"];

                        // We've found a descendant, alter the indent level
                        if ($desc_indent_level > $indent_level) {
                                $promote_sql = "UPDATE element SET indent_level = indent_level - 1 WHERE page_id = "
                                        . $page_id
                                        . " AND element_id = "
                                        . $desc_element_id;
                                xx_tryquery($promote_sql);

                        } // end of check for one descendant
                        
                        
                        /*
                        Reset the parent ID on the immediate first-generation children.
                        Note that at this point they have the same indent level as their
                        parent in the database, but differ here in PHP.
                        */
                        
                        if ($desc_indent_level == $indent_level + 1) {
                        
                                $newparent_sql = "UPDATE element SET parent_id = "
                                        . $parent_id
                                        . " WHERE page_id = "
                                        . $page_id
                                        . " AND element_id = "
                                        . $desc_element_id;
                                xx_tryquery($newparent_sql);
                        
                        } // end check for first generation children

                } // end check for all descendants

                // Next, delete the parent
                $parent_sql = "DELETE FROM element WHERE element_id = "
                        . $element_id;
                xx_tryquery($parent_sql);
                
                // Increment the deleted counter to include the parent
                $num_desc++;

                // Next, update the order of the remainders             
                $order_sql = "UPDATE element SET element_order = element_order - 1 WHERE page_id = "
                        . $page_id
                        . " AND element_order > "
                        . $element_order;
                xx_tryquery($order_sql);

                // Last, delete the (parent) element reference from the stats database
                $sql = "DELETE from libstats.elementstats WHERE page_id = "
                        . $page_id
                        . " AND element_id = "
                        . $element_id;
                xx_tryquery($sql);

                // Done, return to page
                if ($position > 2) $new_pos = $position - 1;
                else $new_pos = 1;
                header("Location: scribe.phtml?page_id=". $page_id . "#p" . $new_pos);
                
        } // end delete and promote


        /********************************
        ** Delete element and children **
        ********************************/

        
        else if ($promote == 2) {

                // Intialize first descendant indent level to proper value
                $desc_indent_level = $indent_level + 1;
                $num_desc = 0;

                /* First, we need to march through the records, starting at the
                first child, and purge any with an indent level equal to or
                greater than the first child.  When we reach an indent level
                equal to the parent, we are now dealing with a sibling (of
                the parent) and stop.  It may possible to do this recursively,
                but it might involve more SQL's and probably represent less
                clear logic.
                */

                $sql = "SELECT element_id, parent_id, indent_level, element_order FROM element WHERE page_id = "
                        . $page_id
                        . " AND element_order > "
                        . $element_order
                        . " ORDER BY element_order";
                $rs = xx_tryquery($sql);
                
                // Check for and delete all descendants
                while (($row = xx_fetch_array ($rs, xx_ASSOC)) && ($desc_indent_level > $indent_level)) {
                        $desc_element_id = $row["element_id"];
                        $desc_parent_id = $row["parent_id"];
                        $desc_indent_level = $row["indent_level"];

                        // We've found a descendant, delete it                  
                        if ($desc_indent_level > $indent_level) {
                                $delete_sql = "DELETE FROM element WHERE element_id = "
                                        . $desc_element_id;
                                xx_tryquery($delete_sql);
                                
                                // Increment the deleted descendant counter
                                $num_desc++;
                                
                        } // end of check for one descendant

                        // Delete this (descendant) element reference from the stats database
                        $sql = "DELETE from libstats.elementstats WHERE page_id = "
                                . $page_id
                                . " AND element_id = "
                                . $desc_element_id;
                        xx_tryquery($sql);

                } // end check for all descendants
                
                // Delete the parent itself             
                $parent_sql = "DELETE FROM element WHERE element_id = "
                        . $element_id;
                xx_tryquery($parent_sql);

                // Increment the deleted counter to include the parent
                $num_desc++;
                
                // Next, update the order of the remainders             
                $order_sql = "UPDATE element SET element_order = element_order - "
                        . $num_desc
                        . " WHERE page_id = "
                        . $page_id
                        . " AND element_order > "
                        . $element_order;
                xx_tryquery($order_sql);

                // Last, delete the (parent) element reference from the stats database
                $sql = "DELETE from libstats.elementstats WHERE page_id = "
                        . $page_id
                        . " AND element_id = "
                        . $element_id;
                xx_tryquery($sql);

                // Done, return to page
                if ($position > 2) $new_pos = $position - 1;
                else $new_pos = 1;
                header("Location: scribe.phtml?page_id=". $page_id . "#p" . $new_pos);

        } // end delete parent and children

} // end function


/********************************************************** 
Function: deletePage
Author: Paul Bramscher
Last Modified: 03.16.2004
***********************************************************
Purpose:
Deletes the supplied page id.  In doing so, elements,
assigned page staff, course information, assigned course
personnel, and the page itself are deleted.

This function also deletes any references to the supplied
page id in the libstats database, including element-level
and overall page statistics.
**********************************************************/
function deletePage($page_id){

        // Load globals
        include("global_vars.php");

        // Include the page header
        include ($GLOBAL_ADMIN_INC."scribe_header.phtml");
        
        // HTML header
        printf("<html>\n");
        printf("<head>\n");
        printf("<title>PageScribe: Deleting page...</title>\n");
        printf("<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\">\n", $GLOBAL_ADMIN_CSS);
        printf("</head>\n");

        msgTableOpen(1, "Deleting Page (ID# " . $page_id . ")");
        printf("<b>Messages:</b><br>\n");

        // Purge all 
        if ($page_id > 0) {

                // Initialize
                $course_id = 0;
        
                // First identify whether this is a CourseLib page.  If so, collect the course id.
                $sql = "SELECT course_id FROM course WHERE page_id = "
                        . $page_id;
                        
                $rs = xx_tryquery($sql);
                $row = xx_fetch_array ($rs, xx_ASSOC);

                // Collect the access information
                $course_id = $row["course_id"];

                // Delete all elements first
                $sql = "DELETE from element WHERE page_id =" . $page_id;
                if (xx_tryquery ($sql)) printf("Removed this page's elements.<BR>\n");
                
                // Delete course information, if any
                $sql = "DELETE from course WHERE page_id =" . $page_id;
                if (xx_tryquery ($sql)) printf("Removed course information (if any).<BR>\n");

                // Delete assigned course personnel, if any
                if ($course_id > 0) {

                        $sql = "DELETE from course_personnel WHERE course_id =" . $course_id;
                        if (xx_tryquery ($sql)) printf("Removed assigned course personnel (if any).<BR>\n");
                }
                
                // Delete assigned staff, if any                
                $sql = "DELETE from page_staff WHERE page_id =" . $page_id;
                if (xx_tryquery ($sql)) printf("Removed assigned staff (if any).<BR>\n");

                // Delete assigned subjects, if any             
                $sql = "DELETE from sub_page WHERE page_id =" . $page_id;
                if (xx_tryquery ($sql)) printf("Removed assigned subjects (if any).<BR>\n");

                // Delete element statistics, if any            
                $sql = "DELETE from libstats.elementstats WHERE page_id =" . $page_id;
                if (xx_tryquery ($sql)) printf("Removed page's element statistics (if any).<BR>\n");

                // Delete page overall statistics, if any               
                $sql = "DELETE from libstats.pagestats WHERE page_id =" . $page_id;
                if (xx_tryquery ($sql)) printf("Removed page's overall statistics (if any).<BR>\n");
                
                // Delete the page information
                $sql = "DELETE from page WHERE page_id =" . $page_id;
                if (xx_tryquery ($sql)) printf("Removed page successfully.");   

        }
        else printf("Scribe page not found.");

        printf("<br><br>\n");
        msgTableClose();

        // Link to return to admin console
        adminReturn("");
        
        // Include the footer
        include ($GLOBAL_ADMIN_INC."scribe_footer.phtml");
}


/**********************************************************
Function: deletePageConfirm  
Author: Paul Bramscher  
Last Modified: 03.16.2004
***********************************************************
Purpose:
Confirm prompt to delete the supplied page id.
**********************************************************/
function deletePageConfirm($page_id){

        // Load globals
        include ("global_vars.php");

        // Make sure we have a valid integer type
        $page_id = (int) $page_id;

        // Include the page header
        include ($GLOBAL_ADMIN_INC."scribe_header.phtml");
        
        // HTML header
        printf("<html>\n");
        printf("<head>\n");
        printf("<title>PageScribe: Delete Page?</title>\n");
        printf("<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\">\n", $GLOBAL_ADMIN_CSS);
        printf("</head>\n");
        
        msgTableOpen(1, "Delete Page (ID# " . $page_id . ")?");

        // Check to see if its possible
        $exists = existsRow("page", "page_id", $page_id);
        if ($exists > 0){

                // Lookup the title & author
                $page_title = lookupField("page", "page_id", $page_id, "page_title");
                printf("<b>Page Title:</b> %s<br><br>\n ", $page_title);
                printf("This will permanently remove the page and its various assignments from the system.<br><br>\n");

                // Form to draw the delete button
                printf("<form method = \"POST\" action = \"scribe_transaction.phtml\" >\n");
                printf("<input type = \"Hidden\" name = \"transaction\" value = \"deletePage\" >\n");
                printf("<input type = \"Hidden\" name = \"page_id\" value = \"%d\" >\n", $page_id);    
                printf("<center>\n");

                // Interior table
                printf("<table border=\"0\">\n");
                
                printf("<tr><td>\n");
                printf("<input type =\"Submit\" value=\"Delete!\">\n");
                printf("</center>\n");
                printf("</form>\n");
                printf("</td>\n");
                
                // Cancel button
                printf("<td>\n");
                printf("<form method=\"POST\" action=\"scribe.phtml?page_id=%d\">\n", $page_id);
                printf("<input type=\"hidden\" name=\"cmd\" value=\"\">\n");
                printf("<input type=\"submit\" value=\"Cancel\">\n");
                printf("</form>\n");
                printf("</td></tr>\n");
                
                // Close interior table
                printf("</table>\n");
        }
        
        // Failed
        else if ($exists < 1) printf ("Page not found.  Operation cancelled.<br><br>\n");

        msgTableClose();

        // Link to return to admin console
        adminReturn("");

        // Include the footer
        include ($GLOBAL_ADMIN_INC."scribe_footer.phtml");
}


/********************************************************** 
Function: deletePageStaff
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Delete a staffperson (possibly multiple) associated with
the supplied page id.
**********************************************************/
function deletePageStaff($page_id, $staff_list_array){

        for ($element = 0; $element < sizeof($staff_list_array); $element++) {
                $sql = "DELETE FROM page_staff where page_id = " . $page_id .
                " AND staff_id = " . $staff_list_array[$element];               

                xx_tryquery($sql);
        }
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id . "&cmd=pagestaff");
}


/**********************************************************
Function: displayTOC
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Generates and displays a table of contents (TOC) for the
supplied page id.  This is done dynamically, and uses
root-level elements on the given page.

This function allows for the optional display of a
two-column table of contents, split at the midpoint
(rounded up for odd numbers of root elements).
**********************************************************/
function displayTOC($page_id, $wrap_toc) {

        // Calculate number of elements
        $sql = "SELECT COUNT(*) as num_elements FROM element WHERE indent_level < 1 AND page_id = "
                . $page_id;
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        $num_elements = $row["num_elements"];

        // Calculate midpoint element   
        if ($num_elements > 0) $midpoint = ceil($num_elements / 2);
        else $midpoint = 0;

        if ($num_elements > 0) {

                // Retrieve all elements on that page
                $sql = "SELECT
                        e.element_id,
                        e.label,                
                        r.resource_id,
                        r.title,
                        l.location_id,
                        l.location,
                        v.service_id,
                        v.service,
                        s.staff_id,
                        s.last_name,
                        s.first_name,
                        b.subject_id,
                        b.subject

                        FROM
                        page p
                        LEFT JOIN element e using (page_id)
                        LEFT JOIN resource r on e.resource_id = r.resource_id           
                        LEFT JOIN location l on e.location_id = l.location_id
                        LEFT JOIN service v on e.service_id = v.service_id
                        LEFT JOIN staff s on e.staff_id = s.staff_id
                        LEFT JOIN subject b on e.subject_id = b.subject_id

                        WHERE
                        p.page_id = "
                        . $page_id
                        . " AND e.indent_level < 1 ORDER BY e.element_order";

                $rs = xx_tryquery($sql);

                // Build a general ToC anchor
                printf("<a name=\"toc\"></a>\n");
                printf("<b>Table of Contents:</b><br>\n");
                printf("<table>\n");

                // Build the (single) row
                printf("<tr>\n");

                // Populate the left cell
                printf("<td valign=\"top\"><ul>\n");
                
                $row_num = 0;
                
                while ($row = xx_fetch_array ($rs, xx_ASSOC)) {
                
                        // Check for the midpoint
                        if ($wrap_toc == 1)
                                if ($row_num == $midpoint) {
                        
                                        // Close the ul tag & table cell
                                        printf("</ul>\n");
                                        printf("</td>\n");
                                        
                                        // Start a new one
                                        printf("<td valign=\"top\">\n");
                                        printf("<ul>\n");
                        
                                }
                
                        // General
                        $element_id = $row["element_id"];

                        // Resource
                        $resource_id = $row["resource_id"];                     
                        $title = $row["title"];

                        // Label/unique
                        $label  = $row["label"];

                        // Location
                        $location_id = $row["location_id"];                     
                        $location = $row["location"];

                        // Service
                        $service_id = $row["service_id"];                       
                        $service = $row["service"];

                        // Staff
                        $staff_id = $row["staff_id"];                   
                        $last_name = $row["last_name"];
                        $first_name = $row["first_name"];

                        // Subject
                        $subject_id = $row["subject_id"];                       
                        $subject = $row["subject"];

                        // Determine what sort of element it is
                        $toc_label = "";
                        if ($resource_id > 0) $toc_label = $title;
                        else if (strlen($label) > 0) $toc_label = $label;
                        else if ($location_id > 0) $toc_label = $location;
                        else if ($service_id > 0) $toc_label = $service;
                        else if ($staff_id > 0) $toc_label = $first_name . " " . $last_name;
                        else if ($subject_id > 0) $toc_label = $subject;                        

                        // Last-minute error check
                        if (strlen($toc_label) > 0) printf("<li><a href=\"#toc%d\">%s</a></li>\n", $element_id, $toc_label);    

                        $row_num++;

                } // end elements
                
                // Close things
                printf("</ul>\n");
                printf("</td></tr></table><br>\n");
                
                
        } // at least one item on this page
}


/**********************************************************
Function: elementDown
Author: Paul Bramscher
Last Modified: 03.04.2004
***********************************************************
Incoming:
$element_id             Element to move down
$page_id                Page the element is location on
$position               Position on the page
***********************************************************
Outgoing:
None
***********************************************************
Purpose:
Moves a selected element (and any descendants) down to the
position of the next youngest sibling.  The sibling (and
any of its descendants are moved up).  The main challenge in
the algorithm is the final shuffling phase since it's not
possible move affected elements down, and then move the
other affected elements up -- since they are selected by
their order and duplicate positions will be created this
way.  Therefore, they are moved and written individually
within the same recordset.  One alternative would be to
assign the "down set" temporary orders, over the current
maximum, move the "up set" up, then re-assign the "down set"
to its position.  With the next iteration, perhaps...
**********************************************************/

function elementDown($element_id, $page_id, $position) {
        
        // Get information about the element to move down
        $sql = "SELECT indent_level, parent_id, element_order FROM element WHERE page_id = "
                . $page_id
                . " AND element_id = "
                . $element_id;
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);  
        $down_indent_level = $row["indent_level"];
        $down_element_order = $row["element_order"];
        
        // Identify information about the element to move up
        $sql = "SELECT element_id, element_order, indent_level FROM element WHERE page_id = "
                . $page_id
                . " AND indent_level = "
                . $down_indent_level
                . " AND element_order > "
                . $down_element_order
                . " ORDER BY element_order";

        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);  
        $up_element_id = $row["element_id"];
        $up_element_order = $row["element_order"];
        
        /*
        Determine number of affected children to move down.  Note that we count the
        number of elements from the starting position with an indent level of greater
        than the starting indent level (they are descendents) up to the position of the
        first younger sibling.  Then we add the element itself.
        */
        
        $sql = "SELECT COUNT(*) as down_num FROM element WHERE page_id = "
                . $page_id
                . " AND element_order > "
                . $down_element_order
                . " AND indent_level > "
                . $down_indent_level
                . " AND element_order < "
                . $up_element_order;
        
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);  
        $down_num = $row["down_num"];
        
        // Add the element itself
        $down_num++;

        /*
        Determine number of elements which will be moved up.  Note that we need to
        probe until we hit the next sibling or older generation element.
        */
        
        $sql = "SELECT element_id, indent_level, element_order FROM element WHERE page_id = "
                . $page_id
                . " AND element_order > "
                . $up_element_order
                . " ORDER BY element_order";

        $rs = xx_tryquery($sql);
        
        // Flag to determine the end of this element's lineage
        $lineage = 1;
        
        /*
        Initialize the last affected element to be the next sibling.  It may be overwritten
        the sibling's last descendant (if any).
        */
        
        $stop_element_order = $up_element_order;
        $stop_element_id = $up_element_id;
        
        // Number of descendants
        $up_num = 0;
        
        /*
        March through the list looking for all descendants.  Take note of the last
        descendant affected by a move.
        */
        
        while (($row = xx_fetch_array ($rs, xx_ASSOC)) && $lineage == 1) {
                $desc_element_id = $row["element_id"];
                $desc_indent_level = $row["indent_level"];
                $desc_element_order = $row["element_order"];
                
                if ($desc_indent_level > $down_indent_level) {
                        $up_num++;
                        $stop_element_id = $desc_element_id;
                        $stop_element_order = $desc_element_order;                      
                }
                else {
                        $lineage = 0;
                }
        }

        // Add the younger sibling itself
        $up_num++;

        // Flag to determine whether to move down (1) or up (0)
        $move_down = 1;

        // Begin the update process.  Create a recordset of all affected elements.
        $sql = "SELECT element_id, indent_level, element_order FROM element WHERE page_id = "
                . $page_id
                . " AND element_order >= "
                . $down_element_order
                . " AND element_order <= "
                . $stop_element_order
                . " ORDER BY element_order";
        $rs = xx_tryquery($sql);
                
        while ($row = xx_fetch_array ($rs, xx_ASSOC)) {
                $mod_element_id = $row["element_id"];
                $mod_indent_level = $row["indent_level"];
                $mod_element_order = $row["element_order"];

                /*
                When we've moved the selected elements down, we switch operations and move
                the others up.
                */
                
                if ($mod_element_id == $up_element_id) $move_down = 0;
                
                if ($move_down == 1) {
                        $new_order = $mod_element_order + $up_num;              
                        //printf("move element %d down %d spaces -- %d<BR>", $mod_element_id, $up_num, $new_order);
                }
                else {
                        $new_order = $mod_element_order - $down_num;                    
                        //printf("move element %d up %d spaces -- %d<BR>", $mod_element_id, $down_num, $new_order);
                }
                
                $mod_sql = "UPDATE element SET element_order = "
                        . $new_order
                        . " WHERE page_id = "
                        . $page_id
                        . " AND element_id = "
                        . $mod_element_id;
                xx_tryquery($mod_sql);                  

        } // all affected elements
        
        /*
        Note: This part is somewhat a kludge.  It typically comes out close,
        but not exact due to the latest scribe engine.  Should do some more
        refinement here.
        
        Position is calculated by N + 2(N - 1) where N = element position.
        We also need to add (3X - 1) of the downset, where X is the number of
        children moved up.
        */
        
        // Position is calculated by N + 2(N - 1) where N = element position.
        // We also need to add the number of elements Z * 3.
        $position = $position + (3 * $up_num);
        
        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position);

}

 
/********************************************************** 
Function: elementMultiFormat
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Incoming:
$auto_font_style        Corresponds to 0-5 CSS style styles
$auto_indent_level      Indent level upon which to apply
                        the changes.
$page_id                Affected CourseLib/PageScribe page
***********************************************************
Outgoing:
None
***********************************************************
Purpose:
Performs a sweep-style format, changing all elements at a
particular indent level to the selected size on the
supplied page id.
**********************************************************/
function elementMultiFormat($auto_element_size, $auto_indent_level, $page_id){
        
        // Build the SQL        
        $sql = "UPDATE element SET element_size = "
                . $auto_element_size
                . " WHERE page_id = "
                . $page_id
                . " AND indent_level = "
                . $auto_indent_level;
        xx_tryquery($sql);      
        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position);        

}


/********************************************************** 
Function: elementSize
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Incoming:
$element_id             Element to perform decrease on
$page_id                Page the element is location on
$position               Position on the page
$size                   Value 1-5 of the element size to
                        utilize.
***********************************************************
Outgoing:
None
***********************************************************
Purpose:
Changes the size code for the specified element.  Values
less than 1 are treated as 0, greater than 5 is treated as
5.  This function is meant to deprecate the elementIncrease()
and elementDecrease() pair of functions.
**********************************************************/
function elementSize($element_id, $page_id, $position, $size){
        
        // Error trap
        if ($size < 1) $size = 0;
        if ($size > 5) $size = 5;
        
        $sql = "UPDATE element SET element_size = "
                . $size
                . " WHERE page_id = "
                . $page_id
                . " AND element_id = "
                . $element_id;
        xx_tryquery($sql);
        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position);
}


/**********************************************************
Function: elementUp
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Incoming:
$element_id             Element to move up
$page_id                Page the element is location on
$position               Position on the page
***********************************************************
Outgoing:
None
***********************************************************
Purpose:
Similar to elementDown, but differs since the user-selected
element is the "up set" rather than the "down set".  See
comments under elementDown for further information.
**********************************************************/
function elementUp($element_id, $page_id, $position) {

        // Get information about the element to move up
        $sql = "SELECT indent_level, parent_id, element_order FROM element WHERE page_id = "
                . $page_id
                . " AND element_id = "
                . $element_id;
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);  
        $up_indent_level = $row["indent_level"];
        $up_element_order = $row["element_order"];
        
        // Identify information about the element which will move down
        $sql = "SELECT element_id, element_order, indent_level FROM element WHERE page_id = "
                . $page_id
                . " AND indent_level = "
                . $up_indent_level
                . " AND element_order < "
                . $up_element_order
                . " ORDER BY element_order DESC";

        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);  
        $down_element_id = $row["element_id"];
        $down_element_order = $row["element_order"];
        
        /*
        Determine number of affected children to move down.  Note that we count the
        number of elements from the starting position with an indent level of greater
        than the starting indent level (they are descendents) up to the position of the
        first younger sibling.  Then we add the element itself.
        */
        
        $sql = "SELECT COUNT(*) as down_num FROM element WHERE page_id = "
                . $page_id
                . " AND element_order > "
                . $down_element_order
                . " AND indent_level > "
                . $up_indent_level
                . " AND element_order < "
                . $up_element_order;
        
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);  
        $down_num = $row["down_num"];
        
        // Add the element itself
        $down_num++;

        /*
        Determine number of elements which will be moved up.  Note that we need to
        probe until we hit the next sibling or older generation element.
        */
        
        $sql = "SELECT element_id, indent_level, element_order FROM element WHERE page_id = "
                . $page_id
                . " AND element_order > "
                . $up_element_order
                . " ORDER BY element_order";
        $rs = xx_tryquery($sql);
        
        // Flag to determine the end of this element's lineage
        $lineage = 1;
        
        /*
        Initialize the last affected element to be the next sibling.  It may be overwritten
        the sibling's last descendant (if any).
        */
        
        $stop_element_order = $up_element_order;
        $stop_element_id = $up_element_id;
        
        // Number of descendants
        $up_num = 0;
        
        /*
        March through the list looking for all descendants.  Take note of the last
        descendant affected by a move.
        */
        
        while (($row = xx_fetch_array ($rs, xx_ASSOC)) && $lineage == 1) {
                $desc_element_id = $row["element_id"];
                $desc_indent_level = $row["indent_level"];
                $desc_element_order = $row["element_order"];
                
                if ($desc_indent_level > $up_indent_level) {
                        $up_num++;
                        $stop_element_id = $desc_element_id;
                        $stop_element_order = $desc_element_order;                      
                }
                else {
                        $lineage = 0;
                }
        }

        // Add the younger sibling itself
        $up_num++;

        // Flag to determine whether to move down (1) or up (0)
        $move_down = 1;

        // Begin the update process.  Create a recordset of all affected elements.
        $sql = "SELECT element_id, indent_level, element_order FROM element WHERE page_id = "
                . $page_id
                . " AND element_order >= "
                . $down_element_order
                . " AND element_order <= "
                . $stop_element_order
                . " ORDER BY element_order";
        $rs = xx_tryquery($sql);
                
        while ($row = xx_fetch_array ($rs, xx_ASSOC)) {
                $mod_element_id = $row["element_id"];
                $mod_indent_level = $row["indent_level"];
                $mod_element_order = $row["element_order"];

                /*
                When we've moved the selected elements down, we switch operations and move
                the others up.
                */
                
                if ($mod_element_id == $element_id) $move_down = 0;             
                
                if ($move_down == 1) {
                        $new_order = $mod_element_order + $up_num;              
                        //printf("move element %d down %d spaces -- %d<BR>", $mod_element_id, $up_num, $new_order);
                }
                else {
                        $new_order = $mod_element_order - $down_num;                    
                        //printf("move element %d up %d spaces -- %d<BR>", $mod_element_id, $down_num, $new_order);
                }
                
                $mod_sql = "UPDATE element SET element_order = "
                        . $new_order
                        . " WHERE page_id = "
                        . $page_id
                        . " AND element_id = "
                        . $mod_element_id;
                xx_tryquery($mod_sql);          
                
        } // all affected elements
        
        // Position is calculated by N + 2(N - 1) where N = element position.
        $position = $down_element_order + (2 * $down_element_order - 1);
        
        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position);

}


/**********************************************************
Function: getMaxIndent
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Return the maximum indent level for the supplied page id.
**********************************************************/
function getMaxIndent($page_id){

        // Initialize
        $max_indent = 0;

        // Build the query
        $sql = "SELECT MAX(indent_level) AS max_indent FROM element WHERE page_id = "
                . $page_id;
                
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        $max_indent = $row["max_indent"];

        return $max_indent;
}


/**********************************************************
Function: insertCoursePers
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Associates the incoming personnel information with the
supplied course id.  Note that the incoming may be one of
three types of personnel: a library staff person, a faculty
member (existing or newly created on the fly), or a
non-indexed TA.
**********************************************************/
function insertCoursePers($course_id, $faculty_id,
        $page_id, $pers_email, $pers_firstname, $pers_lastname,
        $pers_type, $pers_account, $staff_id, $stafftitle_id){
        
        // Error flag
        $err_code = 0;

        // Incoming was library staff
        if ($staff_id > 1) {
                $sql = "INSERT INTO course_personnel (course_id, stafftitle_id, staff_id) VALUES ("
                        . $course_id
                        . ", "
                        . $stafftitle_id
                        . ", "
                        . $staff_id
                        . ")";
        
        }

        // Incoming was faculty
        else if ($faculty_id > 1) {
                $sql = "INSERT INTO course_personnel (course_id, stafftitle_id, faculty_id) VALUES ("
                        . $course_id
                        . ", "
                        . $stafftitle_id
                        . ", "
                        . $faculty_id
                        . ")";  
        
        }
        
        // Incoming was a new faculty member
        else if (strlen($pers_lastname) > 0 && $pers_type == "faculty") {

                // Check for uniqueness
                $faculty_name_display = $pers_firstname . " " . $pers_lastname;
                $exists_id = existsFaculty($pers_firstname, $pers_lastname);

                if ($exists_id > 0) {
                        $err_code = 1;
                        $err_msg = "Failed. '" . $faculty_name_display . "' already exists in the Faculty table.  Faculty firstname + lastname must be unique.";
                }

                // So long as there are no errors
                if ($err_code < 1) {

                        // Clean up strings
                        if (strlen($pers_lastname) > 0) $pers_lastname = textInmySQL($pers_lastname);
                        if (strlen($pers_firstname) > 0) $pers_firstname = textInmySQL($pers_firstname);
                        if (strlen($pers_email) > 0) $pers_email = textInmySQL($pers_email);
                        if (strlen($pers_account) > 0) $pers_account = textInmySQL($pers_account);

                        // Insert into the faculty table                
                        $sql = "INSERT INTO faculty (faculty_lastname, faculty_firstname, faculty_account, faculty_email) VALUES ('"
                                . $pers_lastname
                                . "', '"
                                . $pers_firstname
                                . "', '"
                                . $pers_account
                                . "', '"
                                . $pers_email
                                . "')";
                        xx_tryquery($sql);
                        $new_faculty_id = xx_insert_id();

                        // Now, build the SQL for the insert into course_personnel
                        $sql = "INSERT INTO course_personnel (course_id, stafftitle_id, faculty_id) VALUES ("
                                . $course_id
                                . ", "
                                . $stafftitle_id
                                . ", "
                                . $new_faculty_id
                                . ")";
                        
                }
        }
        
        // Incoming was a lowly TA or "other".  Don't index these, plop them into the course_personnel table
        else if (strlen($pers_lastname) > 0 && $pers_type == "other") {

                // Clean up strings
                if (strlen($pers_lastname) > 0) $pers_lastname = textInmySQL($pers_lastname);
                if (strlen($pers_firstname) > 0) $pers_firstname = textInmySQL($pers_firstname);
                if (strlen($pers_email) > 0) $pers_email = textInmySQL($pers_email);
                if (strlen($pers_account) > 0) $pers_account = textInmySQL($pers_account);

                $sql = "INSERT INTO course_personnel (course_id, stafftitle_id, pers_lastname, pers_firstname, pers_account, pers_email) VALUES ("
                        . $course_id
                        . ", "
                        . $stafftitle_id
                        . ", '"
                        . $pers_lastname
                        . "', '"
                        . $pers_firstname
                        . "', '"
                        . $pers_account
                        . "', '"
                        . $pers_email
                        . "')";
        }
        
        // Must have at least a last name.  Send them back to the page.
        else header("Location: scribe.phtml?page_id=" . $page_id);      


        // Proceed if there are no error messages
        if ($err_code == 0) {
                xx_tryquery($sql);

                // Done. Call the PageScribe page back
                header("Location: scribe.phtml?page_id=" . $page_id . "#coursePers");
        
        }
        
        else {

                // Page header
                require_once ($GLOBAL_ADMIN_INC."scribe_header.phtml");
        
                printf("<center><h3>Adding Course Personnel...</h3>\n");
                
                // Table
                printf("<table width = \"60%%\" border = \"3\" cellpadding =\"4\" class=\"backLight\">\n");
                printf("<tr><td>\n");
                printf("<b>Messages:</b><br>\n");
                printf("%s", $err_msg);
                printf("<br><br></td></tr></table>\n");
                printf("</center>\n");
                
                // Page footer
                require_once ($GLOBAL_ADMIN_INC."scribe_footer.phtml");         

        }
        
}


/**********************************************************
Function: insertScribeLabel
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Inserts a "label" or free-text type PageScribe element onto
a PageScribe page.
**********************************************************/
function insertScribeLabel($element_descr, $label, $label_url, $place_array_HTML, $page_id){

        // Clean up strings
        $element_descr = textInmySQL($element_descr);
        $label = textInmySQL($label);

        // Problem flag
        $problem = 0;
        
        // Protect against blank label
        if (strlen($label) < 1) {
                $problem = 1;
        }

        // No problems
        if ($problem == 0) {

                // Error check
                if ($label_url == "http://") $label_url = "";

                // Split by comma separated values
                $place_array = split(",", $place_array_HTML);

                // Break apart place array
                $prev_element_id = $place_array[0];
                $prev_element_order = $place_array[1];
                $prev_indent_level = $place_array[2];
                // $parent_id = $place_array[3];
                $position = $place_array[4];

                // First probe for the new parent_id
                $parent_id = parentProbe($page_id, $prev_element_order, $prev_indent_level);

                // Next, bump all of the following items down by one            
                $sql = "UPDATE element SET element_order = element_order + 1 WHERE page_id = "
                        . $page_id . " AND element_order >= " . $prev_element_order;
                xx_tryquery($sql);

                // Next insert the new label
                $sql = "INSERT INTO element (page_id, label, label_url, element_descr, element_order, indent_level,parent_id) VALUES ("
                        . $page_id . ", '"
                        . $label . "', '"
                        . $label_url . "', '"
                        . $element_descr . "', "
                        . $prev_element_order . ", "
                        . $prev_indent_level . ", "
                        . $parent_id . ")";                     
                xx_tryquery($sql);
        }
        
        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position);        
}


/**********************************************************
Function: insertScribeLocation
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Inserts location type element onto a PageScribe page.
**********************************************************/
function insertScribeLocation($location_id, $place_array_HTML, $page_id){

        // Error checking
        if ($location_id > 0) {

                // Split by comma separated values
                $place_array = split(",", $place_array_HTML);

                // Break apart place array
                $prev_element_id = $place_array[0];
                $prev_element_order = $place_array[1];
                $prev_indent_level = $place_array[2];
                // $parent_id = $place_array[3];
                $position = $place_array[4];

                // First probe for the new parent_id
                $parent_id = parentProbe($page_id, $prev_element_order, $prev_indent_level);

                // Next, bump all of the following items down by one            
                $sql = "UPDATE element SET element_order = element_order + 1 WHERE page_id = "
                        . $page_id . " AND element_order >= " . $prev_element_order;
                xx_tryquery($sql);

                // Next insert the new location
                $sql = "INSERT INTO element (page_id, location_id, element_order, indent_level,parent_id) VALUES ("
                        . $page_id . ", "
                        . $location_id . ", "
                        . $prev_element_order . ", "
                        . $prev_indent_level . ", "
                        . $parent_id . ")";     
                xx_tryquery($sql);
        
        }

        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 
}


/**********************************************************
Function: insertScribeResource
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Inserts a resource type element onto a PageScribe page.
**********************************************************/
function insertScribeResource($place_array_HTML, $resource_id, $page_id){

        // Error checking
        if ($resource_id > 0) {

                // Split by comma separated values
                $place_array = split(",", $place_array_HTML);

                // Break apart place array
                $prev_element_id = $place_array[0];
                $prev_element_order = $place_array[1];
                $prev_indent_level = $place_array[2];
                // $parent_id = $place_array[3];
                $position = $place_array[4];

                // First probe for the new parent_id
                $parent_id = parentProbe($page_id, $prev_element_order, $prev_indent_level);

                // Next, bump all of the following items down by one            
                $sql = "UPDATE element SET element_order = element_order + 1 WHERE page_id = "
                        . $page_id . " AND element_order >= " . $prev_element_order;
                xx_tryquery($sql);

                // Next insert the new resource
                $sql = "INSERT INTO element (page_id, resource_id, element_order, indent_level,parent_id) VALUES ("
                        . $page_id . ", "
                        . $resource_id . ", "
                        . $prev_element_order . ", "
                        . $prev_indent_level . ", "
                        . $parent_id . ")";     
                xx_tryquery($sql);

        }

        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 
}


/**********************************************************
Function: insertScribeRQS
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
This function performs the "RQS harvest".  For the supplied
subject id, collect all of the resources and insert them
as elements onto a PageScribe page.
**********************************************************/
function insertScribeRQS($place_array_HTML, $subject_id, $page_id){

        // Error checking
        if ($subject_id > 0) {

                // Split by comma separated values
                $place_array = split(",", $place_array_HTML);

                // Break apart place array
                $prev_element_id = $place_array[0];
                $prev_element_order = $place_array[1];
                $prev_indent_level = $place_array[2];
                // $parent_id = $place_array[3];
                $position = $place_array[4];

                // First probe for the new parent_id
                $parent_id = parentProbe($page_id, $prev_element_order, $prev_indent_level);

                // Identify the number of new elements to add
                $sql = "SELECT COUNT(*) as num_rqs from res_sub_infotype WHERE subject_id = " . $subject_id;
                $rs = xx_tryquery($sql);
                $row = xx_fetch_array ($rs, xx_ASSOC);

                // Pull out the possible display values
                $num_rqs = $row["num_rqs"];

                // Continue if num_rqs > 0.  If the RQS+ page was empty, skip all of this.
                if ($num_rqs > 0) {

                        // Next, bump all of the following items down by the number of incoming         
                        $sql = "UPDATE element SET element_order = element_order + "
                                . $num_rqs
                                . " WHERE page_id = "
                                . $page_id . " AND element_order >= " . $prev_element_order;
                        xx_tryquery($sql);

                        // Cycle through the resources
                        $sql = "SELECT rsi.resource_id, r.title
                                FROM res_sub_infotype rsi
                                LEFT JOIN resource r using (resource_id)
                                WHERE subject_id = " . $subject_id .
                                " ORDER BY r.title";

                        $rs = xx_tryquery($sql);
                        while ($row = xx_fetch_array ($rs, xx_ASSOC)) {

                                // Fetch resource
                                $resource_id = $row["resource_id"];

                                // Next insert the culled resource
                                $i_sql = "INSERT INTO element (page_id, resource_id, element_order, indent_level,parent_id) VALUES ("
                                        . $page_id . ", "
                                        . $resource_id . ", "
                                        . $prev_element_order . ", "
                                        . $prev_indent_level . ", "
                                        . $parent_id . ")";     
                                xx_tryquery($i_sql);

                                // Increment element order
                                $prev_element_order++;

                        } // for all resources on RQS page

                } // rqs+ page was not empty
        
        }

        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 

}


/**********************************************************
Function: insertScribeRQSLink
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Inserts an RQS subject page element onto a PageScribe page.
**********************************************************/
function insertScribeRQSLink($place_array_HTML, $subject_id, $page_id){

        // Error checking
        if ($subject_id > 0) {

                // Split by comma separated values
                $place_array = split(",", $place_array_HTML);

                // Break apart place array
                $prev_element_id = $place_array[0];
                $prev_element_order = $place_array[1];
                $prev_indent_level = $place_array[2];
                // $parent_id = $place_array[3];
                $position = $place_array[4];

                // First probe for the new parent_id
                $parent_id = parentProbe($page_id, $prev_element_order, $prev_indent_level);

                // Next, bump all of the following items down by one            
                $sql = "UPDATE element SET element_order = element_order + 1 WHERE page_id = "
                        . $page_id . " AND element_order >= " . $prev_element_order;
                xx_tryquery($sql);

                // Next insert the new resource
                $sql = "INSERT INTO element (page_id, subject_id, element_order, indent_level,parent_id) VALUES ("
                        . $page_id . ", "
                        . $subject_id . ", "
                        . $prev_element_order . ", "
                        . $prev_indent_level . ", "
                        . $parent_id . ")";     
                xx_tryquery($sql);

        }

        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 
}


/**********************************************************
Function: insertScribeService
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Inserts a service type element onto a PageScribe page.
**********************************************************/
function insertScribeService($place_array_HTML, $page_id, $service_id){

        // Error checking
        if ($service_id > 0) {

                // Split by comma separated values
                $place_array = split(",", $place_array_HTML);

                // Break apart place array
                $prev_element_id = $place_array[0];
                $prev_element_order = $place_array[1];
                $prev_indent_level = $place_array[2];
                // $parent_id = $place_array[3];
                $position = $place_array[4];

                // First probe for the new parent_id
                $parent_id = parentProbe($page_id, $prev_element_order, $prev_indent_level);

                // Next, bump all of the following items down by one            
                $sql = "UPDATE element SET element_order = element_order + 1 WHERE page_id = "
                        . $page_id . " AND element_order >= " . $prev_element_order;
                xx_tryquery($sql);

                // Next insert the new service
                $sql = "INSERT INTO element (page_id, service_id, element_order, indent_level,parent_id) VALUES ("
                        . $page_id . ", "
                        . $service_id . ", "
                        . $prev_element_order . ", "
                        . $prev_indent_level . ", "
                        . $parent_id . ")";     
                xx_tryquery($sql);
        
        }

        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 
}


/**********************************************************
Function: insertScribeStaff
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Inserts a staffperson as an element on a PageScribe page.
**********************************************************/
function insertScribeStaff($place_array_HTML, $staff_id, $page_id){

        // Split by comma separated values
        $place_array = split(",", $place_array_HTML);

        // Break apart place array
        $prev_element_id = $place_array[0];
        $prev_element_order = $place_array[1];
        $prev_indent_level = $place_array[2];
        // $parent_id = $place_array[3];
        $position = $place_array[4];
        
        // First probe for the new parent_id
        $parent_id = parentProbe($page_id, $prev_element_order, $prev_indent_level);

        // Next, bump all of the following items down by one            
        $sql = "UPDATE element SET element_order = element_order + 1 WHERE page_id = "
                . $page_id . " AND element_order >= " . $prev_element_order;
        xx_tryquery($sql);
                
        // Next insert the new staff
        $sql = "INSERT INTO element (page_id, staff_id, element_order, indent_level,parent_id) VALUES ("
                . $page_id . ", "
                . $staff_id . ", "
                . $prev_element_order . ", "
                . $prev_indent_level . ", "
                . $parent_id . ")";     
        xx_tryquery($sql);

        header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 
}


/**********************************************************
Function: pageLoadStats
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Logs a statistical entry for a PageScribe/CourseLib page
load.  Page id, date, and IP address are currently logged.
It would be relatively trivial to add other fields,
such as browser type, refer URL, etc. both to the database
and this function here.  However, care must be taken so
that the database doesn't grow too large.  Currently there
exists no automatic mechanism to purge or archive stats.
**********************************************************/
function pageLoadStats($page_id){

        // Add a row for page usage
        
        // Fetch user ip
        $user_ip = $GLOBALS["REMOTE_ADDR"];
        
        // Do the stat stuff here
        $sql = "INSERT INTO libstats.pagestats (
                        page_id,
                        visit_date,
                        user_ip) VALUES ("
                        . $page_id
                        . ", now(), '"
                        . $user_ip
                        . "')";
        xx_tryquery($sql);

}


/**********************************************************
Function: pageTemplate
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Performs the clone or copy page functionality.  Note that
the new title is "Copy of:" prefixed to the previous page
title.  Also, not all parameters are copied.  Specifically,
those relating to permissions must be set independently.

This function could probably be cleaned up for efficiency.
The biggest challenge is in handling the parent-child
relationships on the new page.  While the abstract structure
remains the same, the pointers to specific element id's
on the new page are all new and must be calculated on the
fly.
**********************************************************/
function pageTemplate($page_id, $sess_staff_id, $sess_staff_account){

        // First copy the page elements
        $sql = "SELECT * FROM page WHERE page_id = "
                . $page_id;
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        
        // Fetch results
        $style_id = $row["style_id"];
        $pagetype_id = $row["pagetype_id"];     
        $page_title = $row["page_title"];
        $pagetitle_style = $row["pagetitle_style"];     
        $display_toc = $row["display_toc"];
        $wrap_toc = $row["wrap_toc"];   
        $display_up = $row["display_up"];
        $up_text = $row["up_text"];
        
        // Handle possible nulls
        if ($display_toc < 1) $display_toc = "NULL";
        if ($wrap_toc < 1) $wrap_toc = "NULL";  
        if ($display_up < 1) $display_up = "NULL";
        if ($pagetitle_style < 1) $pagetitle_style = "NULL";    
        
        // Clean up strings
        $page_title = textInmySQL($page_title);
        if (strlen($up_text) > 0) $up_text = textInmySQL($up_text);

        // Create new page insert statement


        $sql = "INSERT INTO page
                (date_created,
                account_created,
                staff_coordinator,
                style_id,
                pagetype_id,
                page_title,
                pagetitle_style,
                display_toc,
                wrap_toc,
                display_up,
                up_text)
                VALUES (
                now(), '"
                . $sess_staff_account
                . "', "
                . $sess_staff_id
                . ", "
                . $style_id
                . ", "
                . $pagetype_id
                . ", 'Copy of: "
                . $page_title
                . "', "
                . $pagetitle_style
                . ", "
                . $display_toc
                . ", "
                . $wrap_toc
                . ", "
                . $display_up
                . ", '"
                . $up_text
                . "')";

        xx_tryquery($sql);
        $new_page_id = xx_insert_id();

        // If a new stub was created, and this happens to be a course page, get the course id.
        if ($new_page_id > 0 && $pagetype_id == 3) {    
                $course_id = lookupfield("course", "page_id", $page_id, "course_id");   
        }


        if ($course_id > 0 && $new_page_id > 0) {

                // Copy the course elements
                $sql = "SELECT * FROM course WHERE page_id = "
                        . $page_id;
                $rs = xx_tryquery($sql);
                $row = xx_fetch_array ($rs, xx_ASSOC);

                // Fetch results
                $coursesub_id = $row["coursesub_id"];
                $course_num = $row["course_num"];
                $course_section = $row["course_section"];       
                $course_concat = $row["course_concat"];
                $term_id = $row["term_id"];
                $course_year = $row["course_year"];
                $campus_id = $row["campus_id"]; 
                $courseheader = $row["courseheader"];
                $introheader1 = $row["introheader1"];
                $intromessage1 = $row["intromessage1"];
                $introheader2 = $row["introheader2"];
                $intromessage2 = $row["intromessage2"];

                // Cleanup
                $course_num = textInmySQL($course_num);
                $course_section = textInmySQL($course_section);
                $course_concat = textInmySQL($course_concat);
                $course_year = textInmySQL($course_year);
                $courseheader = textInmySQL($courseheader);
                $introheader1 = textInmySQL($introheader1);
                $intromessage1 = textInmySQL($intromessage1);
                $introheader2 = textInmySQL($introheader2);
                $intromessage2 = textInmySQL($intromessage2);

                // Cleanup for null or numeric values
                if ($coursesub_id < 1) $coursesub_id = 0;
                if ($term_id < 1) $term_id = 0;
                if ($campus_id < 1) $campus_id = 0;             


                // Create new course insert statement


                $sql = "INSERT INTO course
                        (page_id,
                        coursesub_id,
                        course_num,
                        course_section,
                        course_concat,
                        term_id,
                        course_year,
                        campus_id,
                        courseheader,
                        introheader1,
                        intromessage1,
                        introheader2,
                        intromessage2)
                        VALUES ( " .
                        $new_page_id . ", " .
                        $coursesub_id . ", '" .
                        $course_num . "', '" .
                        $course_section . "', 'Copy: " .
                        $course_concat . "'," .
                        $term_id . ", '" .
                        $course_year . "', " .
                        $campus_id . ", '" .
                        $courseheader . "', '" .
                        $introheader1 . "', '" .
                        $intromessage1 . "', '" .
                        $introheader2 . "', '" .
                        $intromessage2 . "')";
                        
                xx_tryquery($sql);

        } // was a CourseScribe type page

        // Next, copy all elements
        // This is not the most efficient method, but it works for now.


        $sql = "SELECT * FROM element WHERE page_id = "
                . $page_id
                . " ORDER BY element_id";

        $rs = xx_tryquery($sql);
        while ($row = xx_fetch_array ($rs, xx_ASSOC)) {

                // Fetch previous values
                $element_id = $row["element_id"];
                $parent_id = $row["parent_id"];
                $resource_id = $row["resource_id"];
                $location_id = $row["location_id"];
                $service_id = $row["service_id"];
                $staff_id = $row["staff_id"];
                $subject_id = $row["subject_id"];               
                $label = $row["label"];
                $label_url = $row["label_url"];
                $element_descr = $row["element_descr"];
                $element_size = $row["element_size"];
                $element_order = $row["element_order"];
                $indent_level = $row["indent_level"];
                
                // Cleanup for null or numeric values
                if ($parent_id < 1) $parent_id = 0;
                if ($resource_id < 1) $resource_id = "NULL";
                if ($location_id < 1) $location_id = "NULL";
                if ($service_id < 1) $service_id = "NULL";
                if ($staff_id < 1 ) $staff_id = "NULL";
                if ($subject_id < 1 ) $subject_id = "NULL";             
                if ($element_size < 1) $element_size = "NULL";
                if ($indent_level < 1) $indent_level = 0;

                // Cleanup for text values
                if (strlen($label) > 0) $label = textInmySQL($label);
                if (strlen($label_url) > 0) $label_url = textInmySQL($label_url);
                if (strlen($element_descr) > 0) $element_descr = textInmySQL($element_descr);

                // Calculate the new parent if needed
                if ($parent_id > 0) $parent_id = parentProbe($new_page_id, $element_order, $indent_level);

                // Insert the element onto the new page
                $clone_sql = "INSERT INTO element (
                        page_id,
                        parent_id,
                        resource_id,
                        location_id,
                        service_id,
                        staff_id,
                        subject_id,
                        label,
                        label_url,
                        element_descr,
                        element_size,
                        element_order,
                        indent_level)
                        VALUES (" .
                        $new_page_id . ", " .
                        $parent_id . ", " .
                        $resource_id . ", " .
                        $location_id . ", " .
                        $service_id . ", " .
                        $staff_id . ", " .
                        $subject_id . ", '" .
                        $label . "', '" .
                        $label_url . "', '" .
                        $element_descr . "', " .
                        $element_size . ", " .
                        $element_order . ", " .
                        $indent_level . ")";
                
                // Execute the query
                xx_tryquery($clone_sql);

        }

        header("Location: scribe.phtml?page_id=" . $new_page_id);

}


/**********************************************************
Function: pageTemplateConfirm
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Prompts the author that he/she is about to template a
page.
**********************************************************/
function pageTemplateConfirm($page_id, $sess_staff_id, $sess_staff_account){

        // Load globals
        include("global_vars.php");

        // Include the page header
        include ($GLOBAL_ADMIN_INC."scribe_header.phtml");

        // HTML headers
        printf("<html>\n");
        printf("<head>\n");
        printf("<title>%s: Confirm Clone & Load</title>\n", $GLOBAL_SYS_NAME);
        printf("<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\">\n", $GLOBAL_ADMIN_CSS);
        printf("</head>\n");    

        // Table
        printf("<center>\n");
        printf("<table width = \"60%%\" border = \"1\" cellpadding =\"4\" class=\"backLight\">\n");
        printf("<tr><td class=\"cellPlain\">\n");
        printf("Confirm Clone & Load");
        printf("</td></tr>\n");
        printf("<tr><td>\n");
        
        // Collect information
        $sql = "SELECT
                p.page_title,
                s.first_name,
                s.last_name,
                s.staff_email
                FROM
                page p,
                staff s
                WHERE
                p.page_id = "
                . $page_id
                . " AND p.staff_coordinator = s.staff_id";

        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        
        $page_title = strip_tags($row["page_title"]);
        $first_name = $row["first_name"];
        $last_name = $row["last_name"];
        $staff_email = $row["staff_email"];
        $staff_name = $first_name . " " . $last_name;
        
        printf("<b>Page Title: </b>%s<br>\n", $page_title);
        printf("<b>Coordinator: </b>%s <a href=\"mailto:%s\">%s</a><br><br>\n", $staff_name, $staff_email, $staff_email);
        printf("Before cloning this page, please consider seeking permission from and/or giving ");
        printf("attribution to the page author(s) of the original work.<br><br>\n");
        
        // Button to continue
        printf("<form method=\"POST\" action=\"scribe_transaction.phtml\">\n");
        printf("<input type=\"hidden\" name =\"transaction\" value = \"pageTemplate\">\n");
        printf("<input type=\"hidden\" name =\"page_id\" value = \"%d\">\n", $page_id);
        printf("<input type=\"hidden\" name =\"sess_staff_account\" value = \"%d\">\n", $sess_staff_account);
        printf("<input type=\"hidden\" name =\"sess_staff_id\" value = \"%d\">\n", $sess_staff_id);
        printf("<center><input type=\"submit\" value=\"Continue\"></center>\n");
        printf("<br><br></td></tr></table>\n");

        // Link to return to admin console
        adminReturn("");        

        printf("</center>\n");

        // Include the footer
        include ($GLOBAL_ADMIN_INC."scribe_footer.phtml");
}


/**********************************************************
Function: parentIs
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Tests the supplied element to determine whether it has any
children.
**********************************************************/
function parentIs($element_id, $page_id){

        // First initialize the number of children
        $num_children = 0;

        $sql = "SELECT COUNT(*) AS num_children FROM element where page_id = "
                . $page_id
                . " AND parent_id = "
                . $element_id;  
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        $num_children = $row["num_children"];
        
        return $num_children;
}


/**********************************************************
Function: parentProbe
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Probes for a parent (if not a root-level element) of the
supplied element order.  For example, what is the parent
of the Nth element on page M?  The parent is calculated by
looking for the first previous element with an indent
(generation) level of precisely one less.
**********************************************************/
function parentProbe($page_id, $prev_element_order, $prev_indent_level){
        
        // If the item's indent level is 0, it is its own parent.  Return 0.
        if ($prev_indent_level < 1) $parent_id = 0;
        
        // Otherwise, probe for the parent
        else {
        
                /* Build the SQL.  We know that the parent must appear earlier in the
                list, so we limit the SQL to same or previous elements for efficiency. */
                
                $sql = "SELECT * FROM element WHERE page_id = "
                        . $page_id
                        . " AND element_order < "
                        . $prev_element_order
                        . " ORDER BY element_order DESC";
                
                // Found parent tag
                $found = 0;
                
                $rs = xx_tryquery($sql);
                while (($row = xx_fetch_array ($rs, xx_ASSOC)) && $found == 0) {

                        /* Cycle through the list, looking for the first item with an indent
                        of less.  */
                        $element_id = $row["element_id"];
                        $indent_level = $row["indent_level"];

                        // Probe for parent.
                        if ($indent_level == ($prev_indent_level - 1)) {
                                $parent_id = $element_id;
                                $found = 1;
                        }                       
                        
                }
        }
        
        // Just in case there was a problem probing
        if ($parent_id < 1) $parent_id = 0;
        
        return $parent_id; 
}


/**********************************************************
Function: pasteElement
Author: Paul Bramscher
Last Modified: 03.11.2004
***********************************************************
Purpose:
Copies the user's copy/paste buffer onto the supplied
PageScribe/CourseScribe page at the specified position.
This sort of logic required a fair amount of coffee to
work out.
**********************************************************/
function pasteElement($element_order, $indent_level, $page_id, $position, $sess_staff_id) {

        // Debug mode: 0=off, 1=on.
        $debug = 0;

        if ($debug == 1) {
                printf("<h3>Element Paste - Debug Mode</h3><br>\n");
                printf("On page id: %d<br>\n", $page_id);
                printf("It will go in order #%d<br>\n", $element_order);
                printf("Afterwards you'll return to pos: %d<br>\n", $position);
        }
        
        
        // First determine number of elements in buffer
        $sql = "SELECT COUNT(*) as buffer_size FROM pastebuffer WHERE paste_staff_id = "
                . $sess_staff_id
                . " ORDER BY element_order";
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        $buffer_size = $row["buffer_size"];     
        
        if ($debug == 1) printf("Number of elements in buffer: %s<br>\n", $buffer_size);


        // Determine parent ID of first pasted element
        $sql = "SELECT element_id from element WHERE page_id = "
                . $page_id
                . " AND element_order = "
                . $element_order;
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        $adjust_parent_id = $row["element_id"]; 
        
        if ($debug == 1) printf("Parent of first element will be: %d<BR>", $adjust_parent_id);

        
        // Next bump down all elements after the affected element
        $sql = "UPDATE element set element_order = element_order + "
                . $buffer_size
                . " WHERE page_id = "
                . $page_id
                . " AND element_order >= "
                . $element_order;
        
        if ($debug == 1) printf("bump down sql was: %s<br>\n", $sql);   

        xx_tryquery($sql);
        
        // Select from the paste buffer
        $sql = "SELECT * FROM pastebuffer WHERE paste_staff_id = "
                . $sess_staff_id
                .  " ORDER BY element_order";
        $rs = xx_tryquery($sql);

        // row count
        $row_num = 0;

        while ($row = xx_fetch_array ($rs, xx_ASSOC)) {

                // Load copy-paste buffer elements
                $copy_indent_level = $row["indent_level"];
                $copy_parent_id = $row["parent_id"];
                $copy_resource_id = $row["resource_id"];
                $copy_location_id = $row["location_id"];
                $copy_service_id = $row["service_id"];
                $copy_staff_id = $row["staff_id"];
                $copy_subject_id = $row["subject_id"];          
                $copy_label = $row["label"];
                $copy_label_url = $row["label_url"];
                $copy_element_descr = $row["element_descr"];
                $copy_element_size = $row["element_size"];
                $copy_element_order = $row["element_order"];
                
                // Initialize as necessary -- all values must be set
                if ($copy_indent_level <1) $copy_indent_level = 0;
                if ($copy_parent_id < 1) $copy_parent_id = 0;
                if ($copy_resource_id < 1) $copy_resource_id = "NULL";
                if ($copy_location_id < 1) $copy_location_id = "NULL";
                if ($copy_service_id < 1) $copy_service_id = "NULL";
                if ($copy_subject_id < 1) $copy_subject_id = "NULL";            
                if ($copy_staff_id < 1) $copy_staff_id = "NULL";
                if ($copy_element_size < 1) $copy_element_size = "NULL";
                if ($copy_element_order < 1) $copy_element_order = 1;
                
                // Clean up text type entries for insertion
                $copy_label = textInmySQL($copy_label);
                $copy_label_url = textInmySQL($copy_label_url);
                $copy_element_descr = textInmySQL($copy_element_descr);
                
                // Determine the New W0rld 0rder
                $adjust_element_order = $element_order + $row_num;
                                
                /*
                Determine relative indent level.  If this is the first item,
                it will adopt the same indent level as the incoming indent level.
                Everything else will be relative to it.
                */

                if ($row_num == 0) {
                        $adjust_indent_level = $indent_level;
                }
                
                // The copied item is a child
                else if ($copy_indent_level > $last_copy_indent_level) $adjust_indent_level = $last_adjust_indent_level + 1;
                
                // The copied item was older
                else if ($copy_indent_level < $last_copy_indent_level) $adjust_indent_level = $last_adjust_indent_level - 1;
                
                // Else the copied item was a sibling of the last inserted item
                else $adjust_indent_level = $last_adjust_indent_level;

                // Determine parent for all but the first item
                $adjust_parent_id = parentProbe($page_id, $adjust_element_order, $adjust_indent_level);
                
                // Debugging
                if ($debug == 1) {
                        printf("new position start indent:<br>\n");
                        printf("last copy indent: %d, ", $last_copy_indent_level);
                        printf("this copy indent: %d<br>\n", $copy_indent_level);
                        printf("last adjust indent: %d, ", $last_adjust_indent_level);
                        printf("this adjust indent: %d<br>\n", $adjust_indent_level); 
                
                }
                
                // Build the paste SQL
                $p_sql = "INSERT INTO element (
                        page_id,
                        indent_level,
                        parent_id,
                        resource_id,
                        location_id,
                        service_id,
                        staff_id,
                        subject_id,
                        label,
                        label_url,
                        element_descr,
                        element_size,
                        element_order) VALUES ("
                        . $page_id
                        . ", "
                        . $adjust_indent_level
                        . ", "
                        . $adjust_parent_id
                        . ", "
                        . $copy_resource_id
                        . ", "
                        . $copy_location_id
                        . ", "
                        . $copy_service_id
                        . ", "
                        . $copy_staff_id
                        . ", "
                        . $copy_subject_id
                        . ", '"
                        . $copy_label
                        . "', '"
                        . $copy_label_url
                        . "', '"
                        . $copy_element_descr
                        . "', "
                        . $copy_element_size
                        . ", "
                        . $adjust_element_order
                        . ")";

                // Debugging
                if ($debug == 1) printf("insert sql was: %s<br>\n", $p_sql);            

                // Perform the write
                xx_tryquery($p_sql);
                $paste_element_id = xx_insert_id();

                // Debugging
                if ($debug == 1) {
                        printf("insert sql was: %s<br>\n", $p_sql);
                        printf("<b>inserted id was: %d</b><br>\n", $paste_element_id);          
                        printf("<b>adjust parent was: %d</b><br>\n", $adjust_parent_id);
                        printf("<b>adjust order was: %d</b><br><br>\n", $adjust_element_order);         
                }

                // Track some variables
                $last_copy_indent_level = $copy_indent_level;
                $last_adjust_indent_level = $adjust_indent_level;               
                $row_num++;
                
        } // Done pasting all elements
        
        if ($debug == 0) header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position); 
}


/**********************************************************
Function: populateGenArray
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Builds an array from 0 (unused empty placeholder)  to N,
where N is the number of elements on the page, ordered by
the element order.  Each element in the array holds the
indent level (generation) of the page element.  The array
is created outside the function.  This function modifies
and returns it.
**********************************************************/
function populateGenArray(&$genArray, $page_id) {
        
        // Initialize the 0th (unused) array element
        $genArray[0] = 0;

        // Load the page element structure into the array
        $sql = "SELECT element_order, indent_level
                FROM element
                WHERE page_id = "
                . $page_id
                . " ORDER BY element_order";
        $rs = xx_tryquery($sql);
        
        // Start populating generation array subscript [1]
        $rowcount = 1;
        
        while ($row = xx_fetch_array ($rs, xx_ASSOC)) {
        
                // Fetch values
                $element_order = $row["element_order"];
                $indent_level = $row["indent_level"];
                
                // Just in case
                if ($indent_level < 0) $indent_level = 0;
                if ($element_order < 0) $element_order = 0;
                
                array_push($genArray, $indent_level);
                
                $rowcount++;
        }

        return $genArray;
}


/**********************************************************
Function: scribePublish
Author: Paul Bramscher
Last Modified: 03.11.2004
***********************************************************
Purpose:
Performs the PageScribe/CourseLib page publish functionality.
Note that in addition to flipping the published field in the
page table to 1 (TRUE), it also opens a socket to the dynamic
URL for the page, sucks down all page source in 4k blocks,
then concatenates them into the pageHTML field in the page
table.  This creates a static snapshot of the page, which
requires only a single SQL to dump the entire output of the
page.  Use that URL (displayed on the scribe.phtml authoring
page for published pages) if there are concerns about page load
performance issues with the fully dynamic version.
**********************************************************/
function scribePublish($page_id) {


        /*
        First determine whether the current page is (a) a courselib page and
        (b) is missing a course subject/department.  If so, this page cannot
        be published.
        */

        // Initialize
        $coursesub_id = 0;
        $pagetype_id = 0;

        // Build the SQL        
        $sql = "SELECT
                c.coursesub_id,
                p.pagetype_id
                FROM course c, page p
                WHERE p.page_id = "
                . $page_id
                . " AND p.page_id = c.page_id";
        
        // printf("sql was: %s", $sql);
        
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);
        $coursesub_id = $row["coursesub_id"];
        $pagetype_id = $row["pagetype_id"];
        
        // This was a courselib page missing a course/department subject
        // Note that coursesub_id of 1 = N/A, so we don't want this value either.
        if ($coursesub_id < 2 && $pagetype_id == 3) {
        
                // Load globals
                include("global_vars.php");

                // Include the page header
                include ($GLOBAL_ADMIN_INC."scribe_header.phtml");

                // HTML headers
                printf("<html>\n");
                printf("<head>\n");
                printf("<title>%s: Missing Information</title>\n", $GLOBAL_SYS_NAME);
                printf("<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\">\n", $GLOBAL_ADMIN_CSS);
                printf("</head>\n");

                // Draw form heading
                printf("<center><h3>%s: Missing Information</h3>\n", $GLOBAL_SYS_NAME);

                // Table
                printf("<table width = \"60%%\" border = \"1\" cellpadding =\"4\" class=\"backLight\">\n");
                printf("<tr><td>\n");
                printf("<b>Messages:</b><br>\n");
                printf("CourseLib pages may not be published without a course designator. ");
                printf("This is a required field -- please go back and select a course designator. ");
                printf("If one does not apply, this should probably be a PageScribe page instead.<br><br>\n");
        
                printf("</td></tr></table>\n");


                // Link to return to admin console
                adminReturn("");        

                printf("</center>\n");

                // Include the footer
                include ($GLOBAL_ADMIN_INC."scribe_footer.phtml");
        }

// Page may be published
else {

        /*
        Uncomment this portion if the static page functionality is desired.
        PFB: 06-23-2003

                // Load globals
                include ("global_vars.php");

                // Test URL to snapshot
                $page_loc = $GLOBAL_SCRIBE_URL . "page.phtml?page_id=" . $page_id;

                // Clear out existing published information
                // This is important, also, to get rid of a NULL value before performing a CONCAT below.
                $sql = "UPDATE page set pageHTML = '' WHERE page_id = " . $page_id;
                xx_tryquery($sql);

                // Open the filepointer for a screen dump
                $fp = fopen ($page_loc, "r");

                // Open failed
                if (!$fp) {
                    echo "$errstr ($errno)<br>\n";
                }       
                // Continue as long as there's data
                else {
                        fputs ($fp, "GET / HTTP/1.0\r\nHost: %s\r\n\r\n", $page_loc);
                        while (!feof($fp)) {

                                // Fetch the stream
                                $iostream = fgets ($fp,4096);

                                // Replace single quotes with two single quotes
                                $iostream_fix = ereg_replace("'","''",$iostream);

                                // Concatenate the stream into the pageHTML field
                                $sql = "UPDATE page set pageHTML = CONCAT(pageHTML,'" . $iostream_fix . "') WHERE page_id = " . $page_id;
                                xx_tryquery($sql);
                        }

                        // Close up the open file pointer
                        fclose ($fp);

                        // Set published flag to 1
                        $sql = "UPDATE page set published = '1' WHERE page_id = " . $page_id;
                        xx_tryquery($sql);

                } // end open file pointer

                end of comment-out */   

                /*********************************************************************
                ** Comment out this portion if static page functionality is desired **
                *********************************************************************/

                // Set published flag to 1
                $sql = "UPDATE page set published = '1' WHERE page_id = " . $page_id;
                xx_tryquery($sql);

                /***********************
                ** End of comment-out **
                ***********************/

                header("Location: scribe.phtml?page_id=" . $page_id);
        
        }

} // end function


/**********************************************************
Function: scribeUnpublish
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Unpublishes the supplied page id.  Note that we set both
the pageHTML to NULL and flip the published flag back to
0 (FALSE).
**********************************************************/
function scribeUnpublish($page_id) {

        // Build the SQL
        $sql = "UPDATE page SET pageHTML = NULL, published = '0' WHERE page_id =" . $page_id;
        xx_tryquery($sql);

        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: sibProbeElder
Author: Paul Bramscher
Last Modified: 06.30.2003
***********************************************************
Purpose:
Probes the generational array for an elder sibling.  If
found, the function returns TRUE (1).  Note that there is
an optimizing exit condition, namely that if the probed
element's indent level is less than the current indent
level, we've already reached a parent and thus quit
probing early.
**********************************************************/
function sibProbeElder($genArray, $page_id, $place_array){

        // Break apart place array
        $element_id = $place_array[0];
        $element_order = $place_array[1];
        $indent_level = $place_array[2];
        //$parent_id = $place_array[3];
        //$position = $place_array[4];

        // Initialize finding an elder sibling to FALSE
        $elder = 0;

        if ($element_order > 1) {
        
                // Initialize more things
                $probe = $element_order - 1;
                $continue = 1;
        
                while ($elder == 0 && $continue == 1 && $probe >= 1) {  

                        if ($genArray[$probe] == $indent_level) $elder = 1;
                        else if ($genArray[$probe] < $indent_level) $continue = 0;

                        $probe--;
                }
        }
        
        return $elder;
}


/**********************************************************
Function: sibProbeYounger
Author: Paul Bramscher
Last Modified: 06.30.2003
***********************************************************
Purpose:
Probes the generational array for a younger sibling.  If
found, the function returns TRUE (1).  Note that there is
an optimizing exit condition, namely that if the probed
element's indent level is less than the current indent
level, we've already reached a parent (of a separate nuclear
family) and thus quit probing early.
**********************************************************/
function sibProbeYounger($genArray, $page_id, $place_array){

        // Break apart place array
        $element_id = $place_array[0];
        $element_order = $place_array[1];
        $indent_level = $place_array[2];
        //$parent_id = $place_array[3];
        //$position = $place_array[4];

        // Initialize finding a younger sibling to FALSE
        $younger = 0;

        if ($element_order < sizeof($genArray)) {

                // Initialize more things
                $probe = $element_order + 1;
                $continue = 1;
        
                while ($younger == 0 && $continue == 1 && $probe <= sizeof($genArray)) {

                        if ($genArray[$probe] == $indent_level) $younger = 1;
                        else if ($genArray[$probe] < $indent_level) $continue = 0;

                        $probe++;
                }
        }
        
        return $younger;
}


/**********************************************************
Function: toggleTOCDisplay
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Flips the flag to 1 (TRUE) or 0 (FALSE) for the display
of the PageScribe/CourseLib table of contents.  This
ToC is autogenerated and includes the root elements on the
page.
**********************************************************/
function toggleTOCDisplay($display_toc, $page_id) {

        $sql = "UPDATE page SET display_toc = "
                . $display_toc
                . " WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: toggleTOCWrap
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Flips the flag to 1 (TRUE) or 0 (FALSE) for the wrapping
of the PageScribe/CourseLib table of contents.  This
ToC is autogenerated and includes the root elements on the
page.  The wrap results in a two-column view of the ToC.
**********************************************************/
function toggleTOCWrap($page_id, $wrap_toc) {

        $sql = "UPDATE page SET wrap_toc = "
                . $wrap_toc
                . " WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: toggleUpDisplay
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Toggles the display of the [return to top] text on the
supplied page id before each new root element.  If there
is currently no value in the up_text field (i.e. the user
has never saved anything previously), then this function
will also insert a preliminary value as passed from the
default string setting on the scribe authoring page.
**********************************************************/
function toggleUpDisplay($display_up, $page_id, $up_text) {

        // Collect some data on the current up text
        $current_up_text = lookupField("page", "page_id", $page_id, "up_text");

        // Toggle the flag to TRUE or FALSE
        $sql = "UPDATE page SET display_up = "
                . $display_up
                . " WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
        
        /* If the current up_text is blank, and the user has
        toggled ON, then insert the default wording. */
        if ($display_up == 1 && strlen($current_up_text) < 1) {
                $sql = "UPDATE page SET up_text = '"
                        . $up_text
                        . "' WHERE page_id = "
                        . $page_id;
                xx_tryquery($sql);      
        }
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: toggleUpText
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Changes the [return to top] text for the supplied page id,
on a given page id before each new root element.
**********************************************************/
function toggleUpText($page_id, $up_text) {

        // Clean the string
        $up_text = textInmySQL($up_text);

        // Make the change
        $sql = "UPDATE page SET up_text = '"
                . $up_text
                . "' WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: toggleURLDisplay
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
This function updates the display_urls field in the
page table.  When set to 1 (TRUE), URL's are diplayed
during the PageScribe edit mode.

Previously, we used this flag to create pages for which the
URL's ought to be displayed or surpressed to the user
(not merely the page author).  However, with the creation
of the "printer friendly version" of a page, which
automatically displays URL's, the utility here is lessened.
Still, it might be useful for an author to see his/her
URL's in edit mode for a quick visual inspection without
having to resort to the user interface.
**********************************************************/
function toggleURLDisplay($display_urls, $page_id) {

        // Build the SQL
        $sql = "UPDATE page SET display_urls = "
                . $display_urls
                . " WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}

/**********************************************************
Function: updatePageDebug
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Updates the flag for page debug to 1 (TRUE) or 0 (FALSE).

Notes: This is not currently used.  Potentially we could
utilize this flag when TRUE, to run the debugger every
time a page is loaded.
**********************************************************/
function updatePageDebug($page_debug, $page_id) {

        $sql = "UPDATE page SET page_debug = "
                . $page_debug
                . " WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: updatePageHeader
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Updates the supplied page id's pageheader
**********************************************************/
function updatePageHeader($page_id, $pageheader) {

        // Clean up
        if (strlen($pageheader) > 0) $pageheader = textInmySQL($pageheader);

        $sql = "UPDATE page SET pageheader = '"
                . $pageheader
                . "' WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);

        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: updatePageTitleStyle
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Updates the style class for the supplied page_id
**********************************************************/
function updatePageTitleStyle($page_id, $pagetitle_style) {

        $sql = "UPDATE page SET pagetitle_style = "
                . $pagetitle_style
                . " WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
        
        // Call the PageScribe page back
        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: updateScribeCourse
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Updates the supplied field and value for the course id.
The concatenated course title is also updated, in case
there were modifications which affect the title
(subject, designator, or section).
**********************************************************/
function updateScribeCourse($course_id, $field_name, $field_value, $page_id) {

        // Clean up for entry
        if (strlen($field_value) > 0) $field_value = textInmySQL($field_value);

        // Determine whether this is an existing course or a new one
        if ($course_id > 0) {

                // Build the SQL.  Key on both course_id and page_id for safety sake.
                $sql = "UPDATE course SET "
                        . $field_name
                        .  " = '"
                        . $field_value
                        . "' WHERE course_id = "
                        . $course_id
                        . " AND page_id = "
                        . $page_id;
                xx_tryquery($sql);


        }
        
        // New course 
        else {
                $sql = "INSERT INTO course ('"
                        . $field_name
                        . "', page_id) VALUES ('"
                        . $field_value
                        . "', "
                        . $page_id
                        . ")";
                
                xx_tryquery($sql);
                $course_id = xx_insert_id();

        }
        updateScribeCourseConcat($course_id, $page_id);
}

/**********************************************************
Function: updateScribeCourseConcat
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
This function updates a CourseLib course title of the
supplied page id and course id.  This course title is a
concatenation of the course subject + designator +
section (if provided).  This was done because there was a
problem in sorting multiple fields with our version of
mySQL.  We needed to present a completely ordered list of
courses -- not merely by course subject.
**********************************************************/
function updateScribeCourseConcat($course_id, $page_id) {

        // Fetch course related information
        $sql = "SELECT
                p.page_title,
                c.course_num,
                c.course_section,
                s.coursesub_id,
                s.coursesub
                FROM
                course c
                LEFT JOIN page p using (page_id)
                LEFT JOIN coursesub s on c.coursesub_id = s.coursesub_id
                
                WHERE
                course_id = " . $course_id;
        
        $rs = xx_tryquery($sql);
        $row = xx_fetch_array ($rs, xx_ASSOC);

        $page_title = $row["page_title"];
        $coursesub_id = $row["coursesub_id"];   
        $coursesub = $row["coursesub"];
        $course_num = $row["course_num"];
        $course_section = $row["course_section"];
        
        // Initialize
        $course_concat = "";
        
        // So long as the course subject is not N/A
        // if ($coursesub_id > 1) $course_concat = $coursesub . " ";
        if ($coursesub_id > 1) $course_concat = $coursesub;

        //if (strlen($course_num) > 1) $course_concat = $course_concat . $course_num . " ";
        //$course_concat = $course_concat . $page_title . " ";

        if (strlen($course_num) > 1) $course_concat = $course_concat . " " . $course_num . ": ";
        else $course_concat = $course_concat . " ";
        $course_concat = $course_concat . $page_title . " ";

        if (strlen($course_section) > 1) $course_concat = $course_concat . $course_section . " ";
        
        // Clean up
        $course_concat = textInmySQL($course_concat);
        
        // Update the concatenated title into the course table
        $sql = "UPDATE course SET course_concat = '"
                . $course_concat
                . "' WHERE course_id = "
                . $course_id;
        xx_tryquery($sql);
        
        header("Location: scribe.phtml?page_id=" . $page_id);

}

/**********************************************************
Function: updateScribeElement
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Updates a PageScribe element.  This function handles the
updating of text or label type elements, their url's and
descriptions -- as well as customized descriptions for
any other element type.
**********************************************************/
function updateScribeElement($element_descr,
        $element_id, $label, $label_flag, $label_url, $page_id, $position) {

        // Problem flagging
        $problem = 0;

        // Clean up strings
        if (strlen($element_descr) > 0) $element_descr = textInmySQL($element_descr);
        if (strlen($label) > 0) $label = textInmySQL($label);
        if (strlen($label_url) > 0) $label_url = textInmySQL($label_url);

        // Protection against no url supplied
        if ($label_url == "http://") $label_url = "";

        /*
        Protection against a blank label.  If this element type is a label, some text
        must be supplied.
        */

        if ($label_flag == 1 && strlen($label) < 1) {
                $problem = 1;
                printf("Error.  You must provide a text label if you wish it to be on the page.<br>\n");
        }


        // If no problems
        if ($problem == 0) {

                /*
                First handle text-label type elements.  It is assumed they
                are all non-default descriptions.
                */

                if ($label_flag == 1) {
                        // Build the SQL
                        $sql = "UPDATE element SET element_descr = '"
                                . $element_descr
                                . "', label = '"
                                . $label
                                . "', label_url = '"
                                . $label_url
                                . "' WHERE page_id ="
                                . $page_id
                                . " AND element_id = "
                                . $element_id;
                        xx_tryquery($sql);              
                
                
                }

                /*
                This is a non- text-label element, and the user changed the default description.
                */
                
                else if ($label_flag == 0 && strlen($element_descr) > 0) {

                        // Build the SQL
                        $sql = "UPDATE element SET element_descr = '"
                                . $element_descr
                                . "' WHERE page_id ="
                                . $page_id
                                . " AND element_id = "
                                . $element_id;
                        xx_tryquery($sql);

                }

                /*
                This is a non- text-label element.  The user cleared everything out.
                Dump the unique description.  By doing this, the page-rendering interfaces
                will revert to the default description for the element.
                */
                
                else if ($label_flag == 0 && strlen($element_descr) == 0) {

                        // Build the SQL
                        $sql = "UPDATE element SET element_descr = NULL WHERE page_id = "
                                . $page_id
                                . " AND element_id = "
                                . $element_id;
                        xx_tryquery($sql);

                }

                header("Location: scribe.phtml?page_id=" . $page_id . "#p" . $position);

        } // no problems

}


/**********************************************************
Function: updateScribeHeader
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Updates the page title for the supplied page id.
**********************************************************/
function updateScribeHeader($course_id, $page_id, $page_title, $pagetype_id) {

        // Clean up strings
        $page_title = textInmySQL($page_title); 

        // Build the SQL
        $sql = "UPDATE page SET page_title = '"
                . $page_title
                . "' WHERE page_id ="
                . $page_id;
        xx_tryquery($sql);

        // Update the concatenated course title if this is a course page
        if ($pagetype_id == 3) updateScribeCourseConcat($course_id, $page_id);

        header("Location: scribe.phtml?page_id=" . $page_id);

}


/**********************************************************
Function: updateScribeStyle
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Changes the style definition for the supplied page id.
**********************************************************/
function updateScribeStyle($page_id, $style_id) {

        // Build the SQL
        $sql = "UPDATE page SET style_id = "
                . $style_id
                . " WHERE page_id ="
                . $page_id;
        xx_tryquery($sql);

        header("Location: scribe.phtml?page_id=" . $page_id);
}


/**********************************************************
Function: updateScribeUpdate
Author: Paul Bramscher
Last Modified: 03.03.2004
***********************************************************
Purpose:
Modifies the PageScribe/CourseLib page "last updated"
field.
**********************************************************/
function updateScribeUpdate($page_id, $sess_staff_account) {

        $sql = "UPDATE page SET date_modified = now(), account_modified ='"
                . $sess_staff_account
                . "' WHERE page_id = "
                . $page_id;
        xx_tryquery($sql);
}


/**********************************************************
Function: youngerProbe
Author: Paul Bramscher
Last Modified: 10.29.2002
***********************************************************
Incoming:
$page_id                ID of the page involved 
$place_array            Variables related to the last element
                        displayed.
$rs                     Record set with cursor position.
***********************************************************
Outgoing:
$younger                Returns 0 if next element is not
                        younger, 1 if it is.
***********************************************************
Purpose:
Starts out with the cursor pointing at the next element in
the recordset.  Examines the value of its indent level and
determines whether it is older or younger than the previous
element.  If younger, it returns a 1.  If not, returns a 0.

Note that we need some range checking.  $element_order
represents the order 1 to N of the elements on a page,
whereas the cursor sits at positions 0 to (N - 1).  Thus,
we need to make sure we never check beyond the limit of
the number of rows.  After the check, we need to move the
cursor back to $element_order - 1.  This would correspond to
the cursor row it was originally sitting at coming into the
function.
**********************************************************/
function youngerProbe($page_id, $place_array, $rs){

        // Break apart place array
        $element_id = $place_array[0];
        $element_order = $place_array[1];
        $indent_level = $place_array[2];
        //$parent_id = $place_array[3];
        //$position = $place_array[4];

        // Younger found
        $younger = 0;

        if ($element_order <= xx_num_rows($rs)) {               

                $row = xx_fetch_array ($rs);
                $probe_indent_level = $row["indent_level"];
                $probe_element_id = $row["element_id"];
                
                /*
                printf("<BR>this element: %d, this indent: %d<BR>", $element_id, $indent_level);
                printf("probed element: %d, probed indent: %d<BR>", $probe_element_id, $probe_indent_level);
                printf("order was: %d<br>", $element_order);
                */
                
                if ($probe_indent_level > $indent_level) $younger = 1;
                if ($element_order <= xx_num_rows($rs)) xx_data_seek($rs, $element_order - 1);

        }       
        
        return $younger;

}
?>