Methods:	Source:	Variables:
[All Methods \| Documented Methods \| Hide Methods]	[Display Source \| Hide Source]	[Show Variables \| Hide Variables]

::xotcl::Class ::xo::db::CrClass

Class Hierarchy of ::xo::db::CrClass
::xotcl::Object
Meta-class:

::xotcl::Class

Methods for instances:

__api_make_doc, __api_make_forward_doc, __next^C, __timediff, abstract, ad_doc, ad_forward, ad_proc, append^C, array^C, asHTML, autoname^C, check^C, class^C, cleanup^C, configure^C, contains, copy, db_1row^C, debug, defaultmethod, destroy^C, destroy_on_cleanup, eval^C, exists^C, extractConfigureArg, filter^C, filterguard^C, filtersearch^C, forward^C, hasclass, incr^C, info^C, init, instvar^C, invar^C, isclass^C, ismetaclass^C, ismixin^C, isobject^C, istype^C, lappend^C, log, method, mixin^C, mixinguard^C, move, msg, noinit^C, parametercmd^C, proc^C, procsearch^C, qn, requireNamespace^C, self, serialize, set^C, subst^C, trace^C, unset^C, uplevel^C, upvar^C, volatile^C, vwait^C
Methods to be applied on the class (in addition to the methods provided by the meta-class):

__exitHandler, getExitHandler, setExitHandler, unsetExitHandler
::xotcl::Class
Meta-class:

::xotcl::Class

Methods for instances:

ad_instproc, allinstances, alloc^C, autoname^C, create^C, extend_slot, info^C, instdestroy^C, instfilter^C, instfilterguard^C, instforward^C, instinvar^C, instmixin^C, instmixinguard^C, instparametercmd^C, instproc^C, method, new^C, parameter, parameterclass^C, recreate^C, slots^C, superclass^C, unknown^C, uses
Methods to be applied on the class (in addition to the methods provided by the meta-class):

__unknown
::xo::db::Class
Meta-class:

::xotcl::Class

Parameter for instances:

abstract_p (default "f"), auto_save (default "false"), id_column, name_method (default ""), object_type (default "[self]"), pretty_name, pretty_plural, security_inherit_p (default "t"), sql_package_name, supertype (default "acs_object"), table_name, with_table (default "true")

Methods for instances:

check_default_values, check_table_atts, create_object_type, db_slots, dbproc_nonposargs, drop_object_type, fetch_query, fix_function_args, generate_proc_body, generate_psql, get_context, get_function_args, get_instances_from_db, init, init_type_hierarchy, initialize_acs_object, instance_select_query, instantiate_objects, mk_insert_method, mk_save_method, new_acs_object, new_persistent_object, object_types, object_types_query, sql-arguments, table_definition, unknown
Methods to be applied on the class (in addition to the methods provided by the meta-class):

class_to_object_type, create_all_functions, delete, delete_all_acs_objects, drop_type, exists_in_db, get_all_package_functions, get_class_from_db, get_instance_from_db, get_object_type, get_table_name, object_type_exists_in_db, object_type_to_class
::xo::db::CrClass
Meta-class:

::xotcl::Class

Parameter for instances:

edit_form, folder_id (default "-100"), form, mime_type (default "text/plain"), storage_type (default "text"), supertype (default "content_revision")

Methods for instances:

create_object_type, delete, drop_object_type, edit_atts, fetch_object, folder_type, folder_type_unregister_all, getFormClass, get_instance_from_db, get_instances_from_db, init, insert_statement, instance_select_query, lock, mk_insert_method, mk_save_method, new_persistent_object, remember_long_text_slots, require_folder, type_selection_clause, unknown
Methods to be applied on the class (in addition to the methods provided by the meta-class):

delete, get_instance_from_db, get_object_type, lookup, require_folder_object
The meta class CrClass serves for a class of applications that mostly store information in the content repository and that use a few attributes adjoining this information. The class handles the open acs object_type creation and the automatic creation of the necessary tables based on instances of this meta-class.

The definition of new types is handled in the constructor of CrType through the method create_object_type, the removal of the object type is handled through the method drop_object_type (requires that all instances of this type are deleted).

Each content item can be retrieved either through the general method CrClass get_instance_from_db or through the "get_instance_from_db" method of every subclass of CrItem.
This Class is a meta-class providing methods for Classes managing CrItems.

Defined in packages/xotcl-core/tcl/cr-procs.tcl
Class Relations

superclass: ::xo::db::Class

instmixin: ::xo::db::CrCache

mixin: ::xo::db::CrCache::Class

::xotcl::Class create ::xo::db::CrClass \
     -superclass ::xo::db::Class \
     -parameter {edit_form {folder_id -100} form {mime_type text/plain} {storage_type "text"} \
       {supertype content_revision}} \
     -instmixin ::xo::db::CrCache \
     -mixin ::xo::db::CrCache::Class

Methods

proc delete (public)

::xo::db::CrClass delete [ -item_id item_id ]

Delete a CrItem in the database

Switches:

-item_id (optional)

::xo::db::CrClass proc delete -item_id {
    set object_type [my get_object_type -item_id $item_id]
    $object_type delete -item_id $item_id
  }

proc get_instance_from_db (public)

::xo::db::CrClass get_instance_from_db [ -item_id item_id ] \
    [ -revision_id revision_id ]

Instantiate the live revision or the specified revision of an CrItem. The XOTcl object is destroyed automatically on cleanup (end of a connection request).

Switches:

-item_id (defaults to "0") (optional)
-revision_id (defaults to "0") (optional)

Returns:
fully qualified object
object containing the attributes of the CrItem

::xo::db::CrClass proc get_instance_from_db {{-item_id 0} {-revision_id 0}} { 
    set object_type [my get_object_type -item_id $item_id -revision_id $revision_id]
    set class [::xo::db::Class object_type_to_class $object_type]
    return [$class get_instance_from_db -item_id $item_id -revision_id $revision_id]
  }

proc get_object_type (public)

::xo::db::CrClass get_object_type [ -item_id item_id ] \
    [ -revision_id revision_id ]

Return the object type for an item_id or revision_id.

Switches:

-item_id (optional)
-revision_id (defaults to "0") (optional)

Returns:
object_type typically an XOTcl class

::xo::db::CrClass proc get_object_type {-item_id {-revision_id 0}} {
    set object_type [ns_cache eval xotcl_object_type_cache  [expr {$item_id ? $item_id : $revision_id}] {
      if {$item_id} {
        db_1row [my qn get_class]  "select content_type as object_type from cr_items where item_id=$item_id"
      } else {
        db_1row [my qn get_class]  "select object_type from acs_objects where object_id=$revision_id"
      }
      return $object_type
    }]
  }

proc lookup (public)

::xo::db::CrClass lookup -name name  [ -parent_id parent_id ]

Check, whether an content item with the given name exists. If the item exists, return its item_id, otherwise 0.

Switches:

-name (required)
-parent_id (defaults to "-100") (optional)

Returns:
item_id

::xo::db::CrClass proc lookup {-name:required {-parent_id -100}} {
    if {[db_0or1row [my qn entry_exists_select] " select item_id from cr_items where name = :name and parent_id = :parent_id"]} {
      return $item_id
    }
    return 0
  }

proc require_folder_object (public)

::xo::db::CrClass require_folder_object [ -folder_id folder_id ] \
    [ -package_id package_id ]

Dummy stub; let specializations define it

Switches:

-folder_id (optional)
-package_id (optional)

::xo::db::CrClass proc require_folder_object {-folder_id -package_id} {
  }

instproc create_object_type (public)

<instance of ::xo::db::CrClass> create_object_type

Create an oacs object_type and a table for keeping the additional attributes.

::xo::db::CrClass instproc create_object_type {} {
    my instvar object_type supertype pretty_name pretty_plural  table_name id_column name_method

    my check_table_atts

    set supertype [my info superclass]
    switch -- $supertype {
      ::xotcl::Object -
      ::xo::db::CrItem {set supertype content_revision}
    }
    if {![info exists pretty_plural]} {set pretty_plural $pretty_name}

    db_transaction {
      ::xo::db::sql::content_type create_type  -content_type $object_type  -supertype $supertype  -pretty_name $pretty_name  -pretty_plural $pretty_plural  -table_name $table_name  -id_column $id_column  -name_method $name_method
      
      #my create_attributes
      my folder_type register
    }
  }

instproc delete (public)

<instance of ::xo::db::CrClass> delete -item_id item_id

Delete a content item from the content repository.

Switches:

-item_id (required)
id of the item to be deleted

::xo::db::CrClass instproc delete -item_id:required {
    ::xo::db::sql::content_item del -item_id $item_id
  }

instproc drop_object_type (public)

<instance of ::xo::db::CrClass> drop_object_type

Delete the object type and remove the table for the attributes. This method should be called when all instances are deleted. It undoes everying what create_object_type has produced.

::xo::db::CrClass instproc drop_object_type {} {
    my instvar object_type table_name
    db_transaction {
      my folder_type unregister
      ::xo::db::sql::content_type drop_type  -content_type $object_type  -drop_children_p t  -drop_table_p t
    }
  }

instproc edit_atts

::xo::db::CrClass instproc edit_atts {} {
    # TODO remove, when name and text are slots (only for generic)
    my array names db_slot
  }

instproc fetch_object (public)

<instance of ::xo::db::CrClass> fetch_object -item_id item_id  \
    [ -revision_id revision_id ] -object object

Load a content item into the specified object. If revision_id is provided, the specified revision is returned, otherwise the live revision of the item_id. If the object does not exist, we create it.

Switches:

-item_id (required)
-revision_id (defaults to "0") (optional)
-object (required)

Returns:
cr item object

::xo::db::CrClass instproc fetch_object {-item_id:required {-revision_id 0} -object:required} {
    #my log "-- [self args]"
    if {![::xotcl::Object isobject $object]} {
      # if the object does not yet exist, we have to create it
      my create $object
    }
    set raw_atts [::xo::db::CrClass set common_query_atts]
    #my log "-- raw_atts = '$raw_atts'"

    set atts [list]
    foreach v $raw_atts {
      switch -glob -- $v {
        publish_status {set fq i.$v}
        creation_date  {set fq o.$v}
        creation_user  {set fq o.$v}
        package_id     {set fq o.$v}
        default        {set fq n.$v}
      }
      lappend atts $fq
    }
    foreach {slot_name slot} [my array get db_slot] {
      switch -- $slot {
	::xo::db::CrItem::slot::text {
	  # We need the rule, since insert the handling of the sql
	  # attribute "text" is somewhat magic. On insert, one can use the
	  # automatic view with column_name "text, on queries, one has to use
	  # "data". Therefore, we cannot use simply -column_name for the slot.
	  lappend atts "n.data AS text"
	}
	::xo::db::CrItem::slot::name {
	  lappend atts i.[$slot column_name]
	}
	default {
	  lappend atts n.[$slot column_name]
	}
      }
    }
    if {$revision_id} {
      $object db_1row [my qn fetch_from_view_revision_id] " select [join $atts ,], i.parent_id  from   [my set table_name]i n, cr_items i,acs_objects o  where  n.revision_id = $revision_id  and    i.item_id = n.item_id  and    o.object_id = $revision_id"
    } else {
      # We fetch the creation_user and the modifying_user by returning the 
      # creation_user of the automatic view as modifying_user. In case of
      # troubles, comment next line out.
      lappend atts "n.creation_user as modifying_user"
      
      $object db_1row [my qn fetch_from_view_item_id] " select [join $atts ,], i.parent_id  from   [my set table_name]i n, cr_items i, acs_objects o  where  i.item_id = $item_id  and    n.[my id_column] = coalesce(i.live_revision, i.latest_revision)  and    o.object_id = i.item_id"
    }

    if {[apm_version_names_compare [ad_acs_version] 5.2] <= -1} {
      $object set package_id [db_string [my qn get_pid]  "select package_id from cr_folders where folder_id = [$object set parent_id]"]
    }

    #my log "--AFTER FETCH\n[$object serialize]"
    $object initialize_loaded_object
    return $object
  }

instproc folder_type (public)

<instance of ::xo::db::CrClass> folder_type \
    [ -include_subtypes include_subtypes ] [ -folder_id folder_id ] \
    operation

register the current object type for folder_id. If folder_id is not specified, use the instvar of the class instead.

Switches:

-include_subtypes (defaults to "t") (optional)
Boolean value (t/f) to flag whether the operation should be applied on subtypes as well
-folder_id (optional)

Parameters:
operation

::xo::db::CrClass instproc folder_type {{-include_subtypes t} -folder_id operation} {
    if {$operation ne "register" && $operation ne "unregister"} {
      error "[self] operation for folder_type must be 'register' or 'unregister'"
    }
    my instvar object_type
    if {![info exists folder_id]} {
      my instvar folder_id
    }
    ::xo::db::sql::content_folder ${operation}_content_type  -folder_id $folder_id  -content_type $object_type  -include_subtypes $include_subtypes
  }

instproc folder_type_unregister_all (public)

<instance of ::xo::db::CrClass> folder_type_unregister_all \
    [ -include_subtypes include_subtypes ]

Unregister the object type from all folders on the system

Switches:

-include_subtypes (defaults to "t") (optional)
Boolean value (t/f) to flag whether the operation should be applied on subtypes as well

::xo::db::CrClass instproc folder_type_unregister_all {{-include_subtypes t}} {
    my instvar object_type
    db_foreach [my qn all_folders] { 
      select folder_id from cr_folder_type_map 
      where content_type = :object_type
    } {
      ::xo::db::sql::content_folder unregister_content_type  -folder_id $folder_id  -content_type $object_type  -include_subtypes $include_subtypes
      }
  }

instproc getFormClass

::xo::db::CrClass instproc getFormClass -data:required {
    if {[$data exists item_id] && [$data set item_id] != 0 && [my exists edit_form]} {
      return [my edit_form]
    } else {
      return [my form]
    }
  }

instproc get_instance_from_db (public)
```
<instance of ::xo::db::CrClass> get_instance_from_db \
    [ -item_id item_id ] [ -revision_id revision_id ]
```
Retrieve either the live revision or a specified revision of a content item with all attributes into a newly created object. The retrieved attributes are strored in the instance variables in class representing the object_type. The XOTcl object is destroyed automatically on cleanup (end of a connection request)

Switches:

-item_id (defaults to "0") (optional)
id of the item to be retrieved.
-revision_id (defaults to "0") (optional)
revision-id of the item to be retrieved.

Returns:
fully qualified object
```
::xo::db::CrClass instproc get_instance_from_db {{-item_id 0} {-revision_id 0}} {
    set object ::[expr {$revision_id ? $revision_id : $item_id}]
    if {![my isobject $object]} {
      my fetch_object -object $object  -item_id $item_id -revision_id $revision_id
      $object destroy_on_cleanup
    }
    return $object
  }
```

instproc get_instances_from_db (public)

<instance of ::xo::db::CrClass> get_instances_from_db \
    [ -select_attributes select_attributes ] \
    [ -from_clause from_clause ] [ -where_clause where_clause ] \
    [ -orderby orderby ] [ -with_subtypes on|off ] \
    [ -folder_id folder_id ] [ -page_size page_size ] \
    [ -page_number page_number ] [ -base_table base_table ]

Returns a set (ordered composite) of the answer tuples of an 'instance_select_query' with the same attributes. The tuples are instances of the class, on which the method was called.

Switches:

-select_attributes (optional)
-from_clause (optional)
-where_clause (optional)
-orderby (optional)
-with_subtypes (boolean) (defaults to "true") (optional)
-folder_id (optional)
-page_size (defaults to "20") (optional)
-page_number (optional)
-base_table (defaults to "cr_revisions") (optional)

::xo::db::CrClass instproc get_instances_from_db {{-select_attributes {}} {-from_clause {}} {-where_clause {}} {-orderby {}} {-with_subtypes:boolean true} -folder_id {-page_size 20} {-page_number {}} {-base_table cr_revisions}} {
    set s [my instantiate_objects -sql  [my instance_select_query  -select_attributes $select_attributes  -from_clause $from_clause  -where_clause $where_clause  -orderby $orderby  -with_subtypes $with_subtypes  -folder_id $folder_id  -page_size $page_size  -page_number $page_number  -base_table $base_table  ]]
    return $s
  }

instproc init

::xo::db::CrClass instproc init {} {
    my instvar object_type db_slot
    # first, do whatever ::xo::db::Class does for initialization ...
    next
    # We want to be able to define for different CrClasses different
    # default mime-types. Therefore, we define attribute slots per 
    # application class with the given default for mime_type. 
    if {[self] ne "::xo::db::CrItem"} {
      my slots {
	::xotcl::Attribute create mime_type -default [my mime_type]
      }
      my db_slots
    }
    # ... then we do the CrClass specific initialization.
    #if {[my info superclass] ne "::xo::db::CrItem"} {
    #  my set superclass [[my info superclass] set object_type]
    #}

    # CrClasses store all attributes of the class hierarchy in
    # db_slot. This is due to the usage of the
    # automatically created views. Note, that classes created with
    # ::xo::db::Class keep only the class specific db slots.
    #
    foreach {slot_name slot} [[my info superclass] array get db_slot] {
      # don't overwrite slots, unless the object_title (named title)
      if {![info exists db_slot($slot_name)] ||
	  $slot eq "::xo::db::Object::slot::object_title"} {
	set db_slot($slot_name) $slot
      }
    }
    my remember_long_text_slots
    
    if {![::xo::db::Class object_type_exists_in_db -object_type $object_type]} {
      my create_object_type
    }
  }

instproc insert_statement

::xo::db::CrClass instproc insert_statement {atts vars} {
      #
      # The Oracle implementation of OpenACS cannot update
      # here *LOBs safely updarted through the automatic generated
      # view. So we postpone these updates and perform these
      # as separate statements.
      #
      set values [list]
      set attributes [list]
      #my msg "--long_text_slots: [my array get long_text_slots]"

      foreach a $atts v $vars {
        #
        # "text" and long_text_slots are handled in Oracle 
        # via separate update statement.
        #
        if {$a eq "text" || [my exists long_text_slots($a)]} continue
        lappend attributes $a
        lappend values $v
      }
      return "insert into [my set table_name]i ([join $attributes ,])  values (:[join $values ,:])"
    }

instproc instance_select_query (public)

<instance of ::xo::db::CrClass> instance_select_query \
    [ -select_attributes select_attributes ] [ -orderby orderby ] \
    [ -where_clause where_clause ] [ -from_clause from_clause ] \
    [ -with_subtypes on|off ] [ -with_children on|off ] \
    [ -publish_status publish_status ] [ -count on|off ] \
    [ -folder_id folder_id ] [ -parent_id parent_id ] \
    [ -page_size page_size ] [ -page_number page_number ] \
    [ -base_table base_table ]

returns the SQL-query to select the CrItems of the specified object_type

Switches:

-select_attributes (optional)
-orderby (optional)
for ordering the solution set
-where_clause (optional)
clause for restricting the answer set
-from_clause (optional)
-with_subtypes (boolean) (defaults to "true") (optional)
return subtypes as well
-with_children (boolean) (defaults to "false") (optional)
return immediate child objects of all objects as well
-publish_status (optional)
one of 'live', 'ready', or 'production'
-count (boolean) (defaults to "false") (optional)
return the query for counting the solutions
-folder_id (optional)
parent_id
-parent_id (optional)
-page_size (defaults to "20") (optional)
-page_number (optional)
-base_table (defaults to "cr_revisions") (optional)
typically automatic view, must contain title and revision_id

Returns:
sql query

::xo::db::CrClass instproc instance_select_query {{-select_attributes {}} {-orderby {}} {-where_clause {}} {-from_clause {}} {-with_subtypes:boolean true} {-with_children:boolean false} -publish_status {-count:boolean false} -folder_id -parent_id {-page_size 20} {-page_number {}} {-base_table cr_revisions}} {
    if {![info exists folder_id]} {my instvar folder_id}
    if {![info exists parent_id]} {set parent_id $folder_id}

    if {$base_table eq "cr_revisions"} {
      set attributes [list ci.item_id ci.name ci.publish_status acs_objects.object_type] 
    } else {
      set attributes [list bt.item_id ci.name ci.publish_status bt.object_type] 
    }
    foreach a $select_attributes {
      if {$a eq "title"} {set a bt.title}
      lappend attributes $a
    }
    set type_selection_clause [my type_selection_clause -base_table $base_table -with_subtypes $with_subtypes]
    #my log "type_selection_clause -with_subtypes $with_subtypes returns $type_selection_clause"
    if {$count} {
      set attribute_selection "count(*)"
      set orderby ""      ;# no need to order when we count
      set page_number  ""      ;# no pagination when count is used
    } else {
      set attribute_selection [join $attributes ,]
    }
    
    set cond [list]
    if {$type_selection_clause ne ""} {lappend cond $type_selection_clause}
    if {$where_clause ne ""}          {lappend cond $where_clause}
    if {[info exists publish_status]} {lappend cond "ci.publish_status eq '$publish_status'"}
    if {$base_table eq "cr_revisions"} {
      lappend cond "acs_objects.object_id = bt.revision_id"
      set acs_objects_table "acs_objects, "
    } else {
      lappend cond "ci.item_id = bt.item_id"
      set acs_objects_table ""
    }
    lappend cond "coalesce(ci.live_revision,ci.latest_revision) = bt.revision_id"
    if {$parent_id ne ""} {
      set parent_clause "ci.parent_id = $parent_id"
      if {$with_children} { 
        lappend cond "($parent_clause or ci.parent_id in (select item_id from cr_items where parent_id = $parent_id))"
      } else {
        lappend cond $parent_clause
      }
    }

    if {$page_number ne ""} {
      set limit $page_size
      set offset [expr {$page_size*($page_number-1)}]
    } else {
      set limit ""
      set offset ""
    }

    set sql [::xo::db::sql select  -vars $attribute_selection  -from "$acs_objects_table cr_items ci, $base_table bt $from_clause"  -where [join $cond " and "]  -orderby $orderby  -limit $limit -offset $offset]
    #my log "--sql=$sql"
    return $sql
  }

instproc lock

::xo::db::CrClass instproc lock {tablename mode} {;}

instproc mk_insert_method

::xo::db::CrClass instproc mk_insert_method {} {;}

instproc mk_save_method

::xo::db::CrClass instproc mk_save_method {} {;}

instproc new_persistent_object (public)

<instance of ::xo::db::CrClass> new_persistent_object \
    [ -package_id package_id ] [ -creation_user creation_user ] \
    [ -creation_ip creation_ip ] args [ args... ]

Create a new content item of the actual class, configure it with the given arguments and insert it into the database. The XOTcl object is destroyed automatically on cleanup (end of a connection request).

Switches:

-package_id (optional)
-creation_user (optional)
-creation_ip (optional)

Parameters:
args

Returns:
fully qualified object

::xo::db::CrClass instproc new_persistent_object {-package_id -creation_user -creation_ip args} {
    my get_context package_id creation_user creation_ip
    my log "ID [self] create $args"
    if {[catch {set p [eval my create ::0 $args]} errorMsg]} {
	my log "Error: $errorMsg, $::errorInfo"
    }
    my log "ID [::0 serialize]"
    set item_id [::0 save_new  -package_id $package_id  -creation_user $creation_user  -creation_ip $creation_ip]
    ::0 move ::$item_id
    ::$item_id destroy_on_cleanup
    return ::$item_id
  }

instproc remember_long_text_slots

::xo::db::CrClass instproc remember_long_text_slots {} {
    #
    # keep long_text_slots in a separate array (for Oracle)
    #
    my array unset long_text_slots
    foreach {slot_name slot} [my array get db_slot] {
      if {[$slot sqltype] eq "long_text"} {
        my set long_text_slots($slot_name) $slot
      }
    }
    #my log "--long_text_slots = [my array names long_text_slots]"
  }

instproc require_folder (public)

<instance of ::xo::db::CrClass> require_folder \
    [ -parent_id parent_id ] [ -content_types content_types ] \
    [ -package_id package_id ] [ -name name ]

Get folder_id for a community id or the actual package. If everything fails, return -100

Switches:

-parent_id (defaults to "-100") (optional)
-content_types (optional)
-package_id (optional)
-name (optional)

Returns:
folder_id

::xo::db::CrClass instproc require_folder {{-parent_id -100} -content_types -package_id -name} {
    my instvar object_type table_name

    if {[info exists package_id]} {
      set cid $package_id
    } else {
      if {[my isobject ::xo::cc]} {
        set package_id [::xo::cc package_id]
        set url [::xo::cc url]
      } elseif {[ad_conn isconnected]} {
        set package_id [ad_conn package_id]
        set url [ad_conn url]
      }

      if {[info exists package_id]} {
        set cid ""
        if {[info command dotlrn_community::get_community_id_from_url] ne ""} {
          set cid [dotlrn_community::get_community_id_from_url -url $url]
        }
        if {$cid eq ""} {
          set cid $package_id
        }
      } else {
        error "Could not determine package id or community id"
      }
    }
    set folder_id [ns_cache eval xotcl_object_type_cache root_folder-$cid {
      set folder_name "$name: $cid"
      
      if {[info command content::item::get_id_by_name] eq ""} {
        set folder_id ""
        db_0or1row [my qn get_id_by_name] "select item_id as folder_id from cr_items  where name = :folder_name and parent_id = :parent_id"
      } else {
        set folder_id [content::item::get_id_by_name  -name $folder_name -parent_id $parent_id]
      }
      if {$folder_id eq ""} {
        set folder_id [content::folder::new  -name $folder_name  -parent_id $parent_id  -package_id $package_id -context_id $cid]
      }
      if {![info exists content_types]} {
        set content_types [::xo::db::Class class_to_object_type [self]]*
        #ns_log notice "CONTENT TYPES = '$content_types'"
      }

      # register all specified content types
      foreach content_type $content_types {
	# if a content_type ends with a *, include subtypes
	set with_subtypes [expr {[regexp {^(.*)[*]$} $content_type _ content_type] ? 
                                 "t" : "f"}]
	::xo::db::sql::content_folder register_content_type  -folder_id $folder_id  -content_type $content_type  -include_subtypes $with_subtypes
      }
      return $folder_id
    }]
    
    return $folder_id
  }

instproc type_selection_clause

::xo::db::CrClass instproc type_selection_clause {{-base_table cr_revisions} {-with_subtypes:boolean false}} {
    my instvar object_type
    if {$with_subtypes} {
      if {$base_table eq "cr_revisions"} {
        # do type selection manually
        return "acs_objects.object_type in ([my object_types_query])"
      }
      # the base-table defines contains the subtypes
      return ""
    } else {
      if {$base_table eq "cr_revisions"} {
        return "acs_objects.object_type = '$object_type'"
      } else {
        return "bt.object_type = '$object_type'"
      }
    }
  }

instproc unknown

::xo::db::CrClass instproc unknown {obj args} {
    my log "unknown called with $obj $args"
  }

Instances

::xo::db::CrItem, ::xowiki::File, ::xowiki::Form, ::xowiki::FormPage, ::xowiki::Object, ::xowiki::Page, ::xowiki::PageInstance, ::xowiki::PageTemplate, ::xowiki::PlainPage, ::xowiki::PodcastItem

Methods:	Source:	Variables:
[All Methods \| Documented Methods \| Hide Methods]	[Display Source \| Hide Source]	[Show Variables \| Hide Variables]

::xotcl::Class ::xo::db::CrClass

Class Hierarchy of ::xo::db::CrClass

Class Relations

Methods

proc delete (public)

proc get_instance_from_db (public)

proc get_object_type (public)

proc lookup (public)

proc require_folder_object (public)

instproc create_object_type (public)

instproc delete (public)

instproc drop_object_type (public)

instproc edit_atts

instproc fetch_object (public)

instproc folder_type (public)

instproc folder_type_unregister_all (public)

instproc getFormClass

instproc get_instance_from_db (public)

instproc get_instances_from_db (public)

instproc init

instproc insert_statement

instproc instance_select_query (public)

instproc lock

instproc mk_insert_method

instproc mk_save_method

instproc new_persistent_object (public)

instproc remember_long_text_slots

instproc require_folder (public)

instproc type_selection_clause

instproc unknown

Instances