Index: openacs-4/packages/acs-content-repository/acs-content-repository.info
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/acs-content-repository.info,v
diff -u -r1.12 -r1.13
--- openacs-4/packages/acs-content-repository/acs-content-repository.info 8 Sep 2001 23:38:24 -0000 1.12
+++ openacs-4/packages/acs-content-repository/acs-content-repository.info 17 Sep 2001 05:16:40 -0000 1.13
@@ -82,6 +82,7 @@
+
@@ -93,9 +94,18 @@
+
+
+
+
+
+
+
+
+
@@ -137,9 +147,14 @@
+
+
+
+
+
Index: openacs-4/packages/acs-content-repository/sql/postgresql/content-create.sql
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/sql/postgresql/content-create.sql,v
diff -u -r1.25 -r1.26
--- openacs-4/packages/acs-content-repository/sql/postgresql/content-create.sql 14 Sep 2001 04:53:02 -0000 1.25
+++ openacs-4/packages/acs-content-repository/sql/postgresql/content-create.sql 17 Sep 2001 05:16:40 -0000 1.26
@@ -1275,7 +1275,7 @@
-- show errors
-- prompt *** Preparing search indices...
--- \i content-search.sql
+\i content-search.sql
Index: openacs-4/packages/acs-content-repository/tcl/item-procs-oracle.xql
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/tcl/Attic/item-procs-oracle.xql,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/acs-content-repository/tcl/item-procs-oracle.xql 17 Sep 2001 05:16:40 -0000 1.1
@@ -0,0 +1,42 @@
+
+
+
+ oracle8.1.6
+
+
+
+
+ select 't' from cr_revisions r, cr_items i
+ where r.revision_id = :revision_id
+ and i.item_id = r.item_id
+ and ((r.content is not null and i.storage_type in ('lob','text')) or
+ (r.filename is not null and i.storage_type = 'file'))
+
+
+
+
+
+
+ select content_item.get_template(:item_id, :context) as template_id
+ from dual
+
+
+
+
+
+
+
+ select content_item.get_path(:item_id) from dual
+
+
+
+
+
+
+
+ select content_item.get_best_revision(:item_id) from dual
+
+
+
+
+
Index: openacs-4/packages/acs-content-repository/tcl/item-procs-postgresql.xql
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/tcl/Attic/item-procs-postgresql.xql,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/acs-content-repository/tcl/item-procs-postgresql.xql 17 Sep 2001 05:16:40 -0000 1.1
@@ -0,0 +1,43 @@
+
+
+
+ postgresql7.1
+
+
+
+
+ select 't' from cr_revisions r, cr_items i
+ where r.revision_id = :revision_id
+ and i.item_id = r.item_id
+ and ((r.content is not null and i.storage_type in ('text','file')) or
+ (r.lob is not null and i.storage_type = 'lob'))
+
+
+
+
+
+
+
+ select content_item__get_template(:item_id, :context) as template_id
+ from dual
+
+
+
+
+
+
+
+ select content_item__get_path(:item_id, null)
+
+
+
+
+
+
+
+ select content_item__get_best_revision(:item_id)
+
+
+
+
+
Index: openacs-4/packages/acs-content-repository/tcl/item-procs.tcl
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/tcl/Attic/item-procs.tcl,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/acs-content-repository/tcl/item-procs.tcl 17 Sep 2001 05:16:40 -0000 1.1
@@ -0,0 +1,280 @@
+namespace eval item {}
+
+
+ad_proc -public item::content_is_null { revision_id } {
+
+ @public content_is_null
+
+ Determines if the content for the revision is null (not mereley
+ zero-length)
+ @param revision_id The revision id
+
+ @return 1 if the content is null, 0 otherwise
+
+} {
+ template::query cin_get_content content_test onevalue "
+ select 't' from cr_revisions
+ where revision_id = :revision_id
+ and content is not null"
+ return [template::util::is_nil content_test]
+}
+
+
+ad_proc -public item::get_template_id { item_id {context public} } {
+
+ @public get_template_id
+
+ Retrieves the template which can be used to render the item. If there is
+ a template registered directly to the item, returns the id of that template.
+ Otherwise, returns the id of the default template registered to the item's
+ content_type. Returns an empty string on failure.
+
+ @param item_id The item id
+ @param context {default 'public'} The context in which the template
+ will be used.
+
+ @return The template_id of the template which can be used to render the
+ item, or an empty string on failure
+
+ @see proc item::get_template_url
+
+} {
+
+ template::query gti_get_template_id template_id onevalue "
+ select content_item.get_template(:item_id, :context) as template_id
+ from dual" -cache "item_itemplate_id $item_id"
+
+ if { [info exists template_id] } {
+ return $template_id
+ } else {
+ return ""
+ }
+}
+
+
+ad_proc -public item::get_template_url { item_id {context public} } {
+
+ @public get_template_url
+
+ Retrieves the relative URL of the template which can be used to
+ render the item. The URL is relative to the TemplateRoot as it is
+ specified in the ini file.
+
+ @param item_id The item id
+ @param context {default 'public'} The context in which
+ the template will be used.
+
+ @return The template_id of the template which can be used to render the
+ item, or an empty string on failure
+
+ @see proc item::get_template_id
+
+} {
+
+ set template_id [get_template_id $item_id $context]
+
+ if { [template::util::is_nil template_id] } {
+ return ""
+ }
+
+ return [get_url $template_id]
+}
+
+
+ad_proc -public item::get_url { item_id } {
+
+ @public get_url
+
+ Retrieves the relative URL stub to th item. The URL is relative to the
+ page root, and has no extension (Example: "/foo/bar/baz").
+
+ @param item_id The item id
+
+ @return The relative URL to the item, or an empty string on failure
+ @see proc item::get_extended_url
+
+} {
+
+ # Get the path
+ template::query gu_get_path item_path onevalue "
+ select content_item.get_path(:item_id) from dual
+ " -cache "item_path $item_id"
+
+ if { [info exists item_path] } {
+ return $item_path
+ } else {
+ return ""
+ }
+}
+
+
+ad_proc -public item::get_live_revision { item_id } {
+
+ @public get_live_revision
+
+ Retrieves the live revision for the item. If the item has no live
+ revision, returns an empty string.
+
+ @param item_id The item id
+
+ @return The live revision id for the item, or an empty string if no
+ live revision exists
+ @see proc item::get_best_revision
+ @see proc item::get_item_from_revision
+
+} {
+
+ template::query glr_get_live_revision live_revision onevalue "
+ select live_revision from cr_items
+ where item_id = :item_id" -cache "item_live_revision $item_id"
+
+ if { [template::util::is_nil live_revision] } {
+ ns_log notice "WARNING: No live revision for item $item_id"
+ return ""
+ } else {
+ return $live_revision
+ }
+}
+
+
+ad_proc -public item::get_mime_info { revision_id {datasource_ref mime_info} } {
+
+ @public get_mime_info
+
+ Creates a onerow datasource in the calling frame which holds the
+ mime_type and file_extension of the specified revision. If the
+ revision does not exist, does not create the datasource.
+
+ @param revision_id The revision id
+ @param datasource_ref {default mime_info} The name of the
+ datasource to be created. The datasource will have two columns,
+ mime_type and file_extension.
+
+ return 1 (one) if the revision exists, 0 (zero) otherwise.
+ @see proc item::get_extended_url
+
+} {
+
+ return [template::query gmi_get_mime_info mime_info onerow "
+ select
+ m.mime_type, m.file_extension
+ from
+ cr_mime_types m, cr_revisions r
+ where
+ r.mime_type = m.mime_type
+ and
+ r.revision_id = :revision_id
+ " -cache "rev_mime_info $revision_id" -uplevel]
+}
+
+
+ad_proc -public item::get_best_revision { item_id } {
+
+ @public get_best_revision
+
+ Attempts to retrieve the live revision for the item. If no live revision
+ exists, attempts to retrieve the latest revision. If the item has no
+ revisions, returns an empty string.
+
+ @param item_id The item id
+
+ @return The best revision id for the item, or an empty string if no
+ revisions exist
+ @see proc item::get_live_revision
+ @see proc item::get_item_from_revision
+
+} {
+ template::query gbr_get_best_revision revision_id onevalue "
+ select content_item.get_best_revision(:item_id) from dual
+ " -cache "item_best_revision $item_id"
+
+ return $revision_id
+}
+
+
+ad_proc -public item::get_extended_url { item_id args } {
+
+ @public get_content_type
+
+ Retrieves the relative URL of the item with a file extension based
+ on the item's mime_type (Example: "/foo/bar/baz.html").
+
+ @param item_id The item id
+
+ @option template_extension Signifies that the file extension should
+ be retrieved using the mime_type of the template assigned to
+ the item, not from the item itself. The live revision of the
+ template is used. If there is no template which could be used to
+ render the item, or if the template has no live revision, the
+ extension defaults to ".html"
+
+ @option revision_id {default the live revision} Specifies the
+ revision_id which will be used to retrieve the item's mime_type.
+ This option is ignored if the -template_extension
+ option is specified.
+
+ @return The relative URL of the item with the appropriate file extension
+ or an empty string on failure
+ @see proc item::get_url
+ @see proc item::get_mime_info
+ @see proc item::get_template_id
+
+} {
+
+ set item_url [get_url $item_id]
+
+ if { [template::util::is_nil item_url] } {
+ ns_log notice "WARNING: No item URL found for content item $item_id"
+ return ""
+ }
+
+ template::util::get_opts $args
+
+ # Get full path
+ set file_url [ns_normalizepath "/$item_url"]
+
+ # Determine file extension
+ if { [info exists opts(template_extension)] } {
+
+ set file_extension "html"
+
+ # Use template mime type
+ set template_id [get_template_id $item_id]
+
+ if { ![template::util::is_nil template_id] } {
+ # Get extension from the template mime type
+ set template_revision_id [get_best_revision $template_id]
+
+ if { ![template::util::is_nil template_revision_id] } {
+ get_mime_info $template_revision_id mime_info
+
+ if { [info exists mime_info] } {
+ set file_extension $mime_info(file_extension)
+ }
+ }
+
+ }
+ } else {
+ # Use item mime type if template extension does not exist
+
+ # Determine live revision, if none specified
+ if { [template::util::is_nil opts(revision_id)] } {
+ set revision_id [get_live_revision $item_id]
+
+ if { [template::util::is_nil revision_id] } {
+ ns_log notice "WARNING: No live revision for content item $item_id"
+ return ""
+ }
+
+ } else {
+ set revision_id $opts(revision_id)
+ }
+
+ get_mime_info $revision_id mime_info
+ set file_extension $mime_info(file_extension)
+ }
+
+ append file_url ".$file_extension"
+
+ return $file_url
+}
Index: openacs-4/packages/acs-content-repository/tcl/item-procs.xql
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/tcl/Attic/item-procs.xql,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/acs-content-repository/tcl/item-procs.xql 17 Sep 2001 05:16:40 -0000 1.1
@@ -0,0 +1,28 @@
+
+
+
+
+
+
+ select live_revision from cr_items
+ where item_id = :item_id
+
+
+
+
+
+
+
+ select
+ m.mime_type, m.file_extension
+ from
+ cr_mime_types m, cr_revisions r
+ where
+ r.mime_type = m.mime_type
+ and
+ r.revision_id = :revision_id
+
+
+
+
+
Index: openacs-4/packages/acs-content-repository/tcl/publish-procs-oracle.xql
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/tcl/publish-procs-oracle.xql,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/acs-content-repository/tcl/publish-procs-oracle.xql 17 Sep 2001 05:16:40 -0000 1.1
@@ -0,0 +1,62 @@
+
+
+
+ oracle8.1.6
+
+
+
+
+
+ begin
+ content_revision.to_temporary_clob(:revision_id);
+ end;
+
+
+
+
+
+
+
+ select
+ content
+ from
+ cr_content_text
+ where
+ revision_id = :revision_id
+
+
+
+
+
+
+
+ select [ad_decode $storage_type file "'[cr_fs_path]' || filename" content] from cr_revisions where revision_id = $revision_id
+
+
+
+
+
+
+
+
+ begin
+ content_revision.to_temporary_clob(:revision_id);
+ end;
+
+
+
+
+
+
+
+ select
+ content
+ from
+ cr_content_text
+ where
+ revision_id = :revision_id
+
+
+
+
+
Index: openacs-4/packages/acs-content-repository/tcl/publish-procs-postgresql.xql
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/tcl/publish-procs-postgresql.xql,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/acs-content-repository/tcl/publish-procs-postgresql.xql 17 Sep 2001 05:16:40 -0000 1.1
@@ -0,0 +1,62 @@
+
+
+
+ postgresql7.1
+
+
+
+
+ select 1
+
+
+
+
+
+
+
+ select
+ content
+ from
+ cr_revisions
+ where
+ revision_id = :revision_id
+
+
+
+
+
+
+
+ select case when i.storage_type = 'file'
+ then '[cr_fs_path]' || r.content
+ when i.storage_type = 'lob'
+ then lob::text
+ else r.content end as content, i.storage_type
+ from cr_revisions r, cr_items i
+ where r.item_id = i.item_id and r.revision_id = $revision_id
+
+
+
+
+
+
+
+ select 1
+
+
+
+
+
+
+
+ select
+ content
+ from
+ cr_revisions
+ where
+ revision_id = :revision_id
+
+
+
+
+
Index: openacs-4/packages/acs-content-repository/tcl/publish-procs.tcl
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-content-repository/tcl/publish-procs.tcl,v
diff -u
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ openacs-4/packages/acs-content-repository/tcl/publish-procs.tcl 17 Sep 2001 05:16:40 -0000 1.1
@@ -0,0 +1,1074 @@
+
+namespace eval publish {
+
+ variable item_id_stack
+ variable revision_html
+ namespace eval handle {}
+}
+
+###############################################
+# Procs to maintain the item_id stack
+# main_item_id is always the id at the top of the stack
+
+
+ad_proc -private publish::push_id { item_id {revision_id ""}} {
+
+ @private push_id
+
+ Push an item id on top of stack. This proc is used
+ to store state between child, relation
+ and content tags.
+
+ @param item_id
+ The id to be put on stack
+
+ @param revision_id {default ""}
+ The id of the revision to use. If missing, live
+ revision will most likely be used
+
+ @see proc publish::pop_id
+ @see proc publish::get_main_item_id
+ @see proc publish::get_main_revision_id
+
+} {
+ variable item_id_stack
+ variable revision_html
+
+ if { [template::util::is_nil item_id] } {
+ error "Null id pushed on stack in publish::push_id"
+ }
+
+ # Determine old configuration
+ set old_item_id ""
+ set old_revision_id ""
+
+ if { [info exists ::content::item_id] } {
+ set old_item_id $::content::item_id
+ }
+
+ if { [info exists ::content::revision_id] } {
+ set old_revision_id $::content::revision_id
+ }
+
+ # Preserve old data
+ if { ![template::util::is_nil old_item_id] } {
+
+ set pair [list $old_item_id $old_revision_id]
+
+ if { ![template::util::is_nil item_id_stack] } {
+ set item_id_stack [concat [list $pair] $item_id_stack]
+ } else {
+ # This is the first id pushed - also clear the cache
+ set item_id_stack [list $pair]
+ array unset revision_html
+ }
+ } else {
+ set item_id_stack [list]
+ }
+
+ # Set new data
+ set ::content::item_id $item_id
+ set ::content::revision_id $revision_id
+}
+
+
+ad_proc -private publish::pop_id {} {
+
+ @private pop_id
+
+ Pop the item_id and the revision_id off the top of the stack.
+ Clear the temporary item cache if the stack becomes empty.
+
+ @return The popped item id, or the empty string if the string is
+ already empty
+
+ @see proc publish::push_id
+ @see proc publish::get_main_item_id
+ @see proc publish::get_main_revision_id
+
+} {
+ variable item_id_stack
+
+ set pair [lindex $item_id_stack 0]
+ if { [template::util::is_nil pair] } {
+ #error "Item id stack is empty in publish::pop_id"
+ }
+
+ set item_id_stack [lrange $item_id_stack 1 end]
+
+ # If the stack is now empty, clear the cache
+ if { [template::util::is_nil item_id_stack] } {
+ array unset revision_html
+ }
+
+ set ::content::item_id [lindex $pair 0]
+ set ::content::revision_id [lindex $pair 1]
+
+ return $::content::item_id
+}
+
+
+ad_proc -public publish::proc_exists { namespace_name proc_name } {
+
+ @public proc_exists
+
+ Determine if a procedure exists in the given namespace
+
+ @param namespace_name The fully qualified namespace name,
+ such as "template::util"
+
+ @param proc_name The proc name, such as "is_nil"
+
+ @return 1 if the proc exists in the given namespace, 0 otherwise
+
+} {
+
+ return [expr ![string equal \
+ [namespace eval $namespace_name \
+ "info procs $proc_name"] {}]]
+}
+
+##########################################################
+#
+# Procs for handling mime types
+#
+
+
+ad_proc -public publish::handle_binary_file {
+ item_id revision_id_ref url_ref error_ref args
+} {
+
+ @public handle_binary_file
+
+ Helper procedure for writing handlers for binary files.
+ It will write the blob of the item to the filesystem,
+ but only if -embed is specified. Then, it will attempt to
+ merge the image with its template.
+ This proc accepts exactly the same options a typical handler.
+
+ @param item_id
+ The id of the item to handle
+
+ @param revision_id_ref {required}
+ The name of the variable in the calling frame that will
+ recieve the revision_id whose content blob was written
+ to the filesystem.
+
+ @param url_ref
+ The name of the variable in the calling frame that will
+ recieve the relative URL of the file in the file system
+ which contains the content blob
+
+ @param error_ref
+ The name of the variable in the calling frame that will
+ recieve an error message. If no error has ocurred, this
+ variable will be set to the empty string ""
+
+ @option embed
+ Signifies that the content should be embedded directly in
+ the parent item. -embed is required for this
+ proc, since it makes no sense to handle the binary file
+ in any other way.
+
+ @option revision_id {default The live revision for the item}
+ The revision whose content is to be used
+
+ @option no_merge
+ If present, do NOT merge with the template, in order to
+ prevent infinite recursion in the <content> tag. In
+ this case, the proc will return the empty string ""
+
+ @return The HTML resulting from merging the item with its
+ template, or "" if no template exists or the -no_merge
+ flag was specified
+
+ @see proc publish::handle::image
+
+} {
+
+ template::util::get_opts $args
+
+ upvar $error_ref error_msg
+ upvar $url_ref file_url
+ upvar $revision_id_ref revision_id
+ set error_msg ""
+
+ if { [template::util::is_nil opts(revision_id)] } {
+ set revision_id [item::get_live_revision $item_id]
+ } else {
+ set revision_id $opts(revision_id)
+ }
+
+ # If the embed tag is true, return the html. Otherwise,
+ # just write the image to the filesystem
+ if { [info exists opts(embed)] } {
+
+ set file_url [publish::write_content $revision_id \
+ -item_id $item_id]
+
+ # If write_content aborted, give up
+ if { [template::util::is_nil file_url] } {
+ set error_msg "No URL found for revision $revision_id, item $item_id"
+ return ""
+ }
+
+ # Try to use the registered template for the image
+ if { ![info exists opts(no_merge)] } {
+ set code "publish::merge_with_template $item_id $args"
+ set html [eval $code]
+ # Return the result of merging - could be ""
+ return $html
+ }
+
+ return ""
+
+ } else {
+ set error_msg "No embed specified for handle_binary_file, aborting"
+ return ""
+ }
+
+}
+
+ad_proc -private publish::html_args { argv } {
+
+ @private html_args
+
+ Concatenate a list of name-value pairs as returned by
+ set_to_pairs into a list of "name=value" pairs
+
+ @param argv The list of name-value pairs
+
+ @return An HTML string in format "name=value name=value ..."
+
+ @see proc publish::set_to_pairs
+
+} {
+ set extra_html ""
+ if { ![template::util::is_nil argv] } {
+ foreach { name value } $argv {
+ append extra_html "$name=\"$value\" "
+ }
+ }
+
+ return $extra_html
+}
+
+
+ad_proc -public publish::item_include_tag { item_id {extra_args {}} } {
+
+ @public item_include_tag
+
+ Create an include tag to include an item, in the form
+
+ include src=/foo/bar/baz item_id=item_id
+ param=value param=value ...
+
+
+ @param item_id The item id
+
+ @param extra_args {}
+ A list of extra parameters to be passed to the include
+ tag, in form {name value name value ...}
+
+ @return The HTML for the include tag
+
+ @see proc item::item_url
+ @see proc publish::html_args
+
+} {
+
+ # Concatenate all the extra html arguments into a string
+ set extra_html [publish::html_args $extra_args]""
+ set item_url [item::get_url $item_id]
+ return ""
+}
+
+
+ad_proc -public publish::handle::image { item_id args } {
+
+ The basic image handler. Writes the image blob to the filesystem,
+ then either merges with the template or provides a default ![]()
+ tag. Uses the title for alt text if no alt text is specified
+ externally.
+
+} {
+
+ template::util::get_opts $args
+
+ set html [eval publish::handle_binary_file \
+ $item_id revision_id url error_msg $args]
+
+ # If an error happened, abort
+ if { ![template::util::is_nil error_msg] } {
+ ns_log notice "WARNING: $error_msg"
+ return ""
+ }
+
+ # Return the HTML if we have any
+ if { ![template::util::is_nil html] } {
+ return $html
+ }
+
+ # If the merging failed, output a straight ![]()
tag
+ template::query i_get_image_info image_info onerow "
+ select
+ im.width, im.height, r.title as image_alt
+ from
+ images im, cr_revisions r
+ where
+ im.image_id = :revision_id
+ and
+ r.revision_id = :revision_id
+ " -cache "image_info $revision_id"
+
+ template::util::array_to_vars image_info
+
+ # Concatenate all the extra html arguments into a string
+ if { [info exists opts(html)] } {
+ set extra_html [publish::html_args $opts(html)]
+ set have_alt [expr [lsearch [string tolower $opts(html)] "alt"] >= 0]
+ } else {
+ set extra_html ""
+ set have_alt 0
+ }
+
+ set html "![]($url")
"
+
+ return $html
+
+}
+
+ad_proc -private publish::merge_with_template { item_id args } {
+
+ @private merge_with_template
+
+ Merge the item with its template and return the resulting HTML. This proc
+ is simlar to content::init
+
+ @param item_id The item id
+
+ @option revision_id {default The live revision}
+ The revision which is to be used when rendering the item
+
+ @option html
+ Extra HTML parameters to be passed to the ADP parser, in format
+ {name value name value ...}
+
+ @return The rendered HTML, or the empty string on failure
+
+ @see proc publish::handle_item
+
+} {
+ #set ::content::item_id $item_id
+ set ::content::item_url [item::get_url $item_id]
+
+ template::util::get_opts $args
+
+ # Either auto-get the live revision or use the parameter
+ if { ![template::util::is_nil opts(revision_id)] } {
+ set revision_id $opts(revision_id)
+ } else {
+ set revision_id [item::get_live_revision $item_id]
+ }
+
+ # Get the template
+ set ::content::template_url [item::get_template_url $item_id]
+
+ if { [string equal $::content::template_url {}] } {
+ ns_log notice "MERGE: No template for item $item_id"
+ return ""
+ }
+
+ ns_log notice "MERGE: Template for item $item_id is $::content::template_url"
+
+ # Get the full path to the template
+ set root_path [content::get_template_root]
+ set file_stub [ns_normalizepath "$root_path/$::content::template_url"]
+
+ # Set the passed-in variables
+ if { ![template::util::is_nil opts(html)] } {
+ set adp_args $opts(html)
+ } else {
+ set adp_args ""
+ }
+
+ # Parse the template and return the result
+ publish::push_id $item_id $revision_id
+ ns_log notice "MERGE: Parsing $file_stub"
+ set html [eval "template::adp_parse \"$file_stub\" \[list $adp_args\]"]
+ publish::pop_id
+
+ return $html
+}
+
+
+
+ad_proc -public publish::handle::text { item_id args } {
+
+ Return the text body of the item
+
+} {
+
+ template::util::get_opts $args
+
+ if { [template::util::is_nil opts(revision_id)] } {
+ set revision_id [item::get_live_revision $item_id]
+ } else {
+ set revision_id $opts(revision_id)
+ }
+
+ if { [info exists opts(embed)] } {
+ # Render the child item and embed it in the code
+ if { ![info exists opts(no_merge)] } {
+ set code "publish::merge_with_template $item_id $args"
+ set html [eval $code]
+ } else {
+
+ db_transaction {
+ db_exec_plsql get_revision_id {
+ begin
+ content_revision.to_temporary_clob(:revision_id);
+ end;
+ }
+
+ # Query for values from a previous revision
+
+ template::query get_previous_content html onevalue "
+ select
+ content
+ from
+ cr_content_text
+ where
+ revision_id = :revision_id"
+
+ }
+ }
+ } else {
+
+ # Just create an include tag
+
+ # Concatenate all the extra html arguments into a string
+ if { [info exists opts(html)] } {
+ set extra_args $opts(html)
+ } else {
+ set extra_args ""
+ }
+
+ set html [publish::item_include_tag $item_id $extra_args]
+ }
+
+ return $html
+}
+
+
+ad_proc -public publish::get_mime_handler { mime_type } {
+
+ @public get_mime_handler
+
+ Return the name of a proc that should be used to render items with
+ the given mime-type.
+ The mime type handlers should all follow the naming convention
+
+
+ proc publish::handle::mime_prefix::mime_suffix
+
+
+ If the specific mime handler could not be found, get_mime_handler
+ looks for a generic procedure with the name
+
+
+ proc publish::handle::mime_prefix
+
+
+ If the generic mime handler does not exist either,
+ get_mime_handler returns ""
+
+ @param mime_type
+ The full mime type, such as "text/html" or "image/jpg"
+
+ @return The name of the proc which should be used to handle the mime-type,
+ or an empty string on failure.
+
+ @see proc publish::handle_item
+
+} {
+ set mime_pair [split $mime_type "/"]
+ set mime_prefix [lindex $mime_pair 0]
+ set mime_suffix [lindex $mime_pair 1]
+
+ # Look for the specific handler
+ if { [proc_exists "::publish::handle::${mime_prefix}" $mime_suffix] } {
+ return "::publish::handle::${mime_prefix}::$mime_suffix"
+ }
+
+ # Look for the generic handler
+ if { [proc_exists "::publish::handle" $mime_prefix] } {
+ return "::publish::handle::${mime_prefix}"
+ }
+
+ # Failure
+ return ""
+}
+
+
+ad_proc -private publish::get_main_item_id {} {
+
+ @private get_main_item_id
+
+ Get the main item id from the top of the stack
+
+ @return the main item id
+
+ @see proc publish::pop_id
+ @see proc publish::push_id
+ @see proc publish::get_main_revision_id
+
+} {
+
+ if { ![template::util::is_nil ::content::item_id] } {
+ set ret $::content::item_id
+ } else {
+ error "Item id stack is empty"
+ }
+
+ return $ret
+}
+
+
+ad_proc -private publish::get_main_revision_id {} {
+
+ @private get_main_revision_id
+
+ Get the main item revision from the top of the stack
+
+ @return the main item id
+
+ @see proc publish::pop_id
+ @see proc publish::push_id
+ @see proc publish::get_main_item_id
+
+} {
+
+ if { [template::util::is_nil ::content::revision_id] } {
+ set item_id [get_main_item_id]
+ set ret [item::get_live_revision $item_id]
+ } else {
+ set ret $::content::revision_id
+ }
+
+ return $ret
+}
+
+ad_proc -private publish::handle_item { item_id args } {
+
+ @private handle_item
+
+ Render an item either by looking it up in the the temporary cache,
+ or by using the appropriate mime handler. Once the item is rendered, it
+ is stored in the temporary cache under a key which combines the item_id,
+ any extra HTML parameters, and a flag which specifies whether the item
+ was merged with its template.
+ This proc takes the same arguments as the individual mime handlers.
+
+ @param item_id The id of the item to be rendered
+
+ @option revision_id {default The live revision}
+ The revision which is to be used when rendering the item
+
+ @option no_merge
+ Indicates that the item should NOT be merged with its
+ template. This option is used to avoid infinite recursion.
+
+ @option refresh
+ Re-render the item even if it exists in the cache.
+ Use with caution - circular dependencies may cause infinite recursion
+ if this option is specified
+
+ @option embed
+ Signifies that the content should be statically embedded directly in
+ the HTML. If this option is not specified, the item may
+ be dynamically referenced, f.ex. using the <include>
+ tag
+
+ @option html
+ Extra HTML parameters to be passed to the item handler, in format
+ {name value name value ...}
+
+ @return The rendered HTML for the item, or an empty string on failure
+
+ @see proc publish::handle_binary_file
+ @see proc publish::handle::text
+ @see proc publish::handle::image
+
+} {
+
+ template::util::get_opts $args
+
+ variable revision_html
+
+ # Process options
+ if { [template::util::is_nil opts(revision_id)] } {
+ set revision_id [item::get_live_revision $item_id]
+ } else {
+ set revision_id $opts(revision_id)
+ }
+
+ if { [template::util::is_nil revision_id] } {
+ ns_log notice "HANDLER: No live revision for $item_id"
+ return ""
+ }
+
+ if { [template::util::is_nil opts(no_merge)] } {
+ set merge_str "merge"
+ } else {
+ set merge_str "no_merge"
+ }
+
+ # Create a unique key
+ set revision_key "$merge_str $revision_id"
+ if { ![template::util::is_nil opts(html)] } {
+ lappend revision_key $opts(html)
+ }
+
+ # Pull the item out of the cache
+ if { ![info exists opts(refresh)] && \
+ [info exists revision_html($revision_key)] } {
+
+ ns_log notice "HANDLER: Fetching $item_id from cache"
+ return $revision_html($revision_key)
+
+ } else {
+
+ # Render the item and cache it
+ ns_log notice "HANDLER: Rendering item $item_id"
+ item::get_mime_info $revision_id mime_info
+ set item_handler [get_mime_handler $mime_info(mime_type)]
+
+ if { [template::util::is_nil item_handler] } {
+ ns_log notice "HANDLER: No mime handler for mime type $mime_info(mime_type)"
+ return ""
+ }
+
+ # Call the appropriate handler function
+ set code [list $item_handler $item_id]
+ set code [concat $code $args]
+
+ # Pass the revision_id
+ if { ![info exists opts(revision_id)] } {
+ lappend code -revision_id $revision_id
+ }
+
+ set html [eval $code]
+ ns_log notice "HANDLER: Caching html for revision $revision_id"
+ set revision_html($revision_key) $html
+
+ return $html
+ }
+}
+
+
+ad_proc -public publish::get_html_body { html } {
+
+ @public get_html_body
+
+ Strip the <body> tags from the HTML, leaving just the body itself.
+ Useful for including templates in each other.
+
+ @param html
+ The html to be processed
+
+ @return Everything between the <body> and the </body> tags
+ if they exist; the unchanged HTML if they do not
+
+} {
+
+ if { [regexp -nocase {]*>(.*) } $html match body_text] } {
+ return $body_text
+ } else {
+ return $html
+ }
+}
+
+
+ad_proc -public publish::render_subitem {
+ main_item_id relation_type relation_tag \
+ index is_embed extra_args {is_merge t}
+} {
+
+ @private render_subitem
+
+ Render a child/related item and return the resulting HTML, stripping
+ off the headers.
+
+ @param main_item_id The id of the parent item
+
+ @param relation_type
+ Either