Category

Development Platform
Home > SourceCode/Document > Linux-Unix program > Linux Network > View Code
KTColumns.inc.php.tmp
Package: ktdms-src-oss-3.5.4.zip　[view]
Upload User: wlgs5050
Upload Date: 2016-06-11
Package Size: 30961k
Code Size: 20k
Category:

Linux Network

Development Platform:

PHP

KTColumns.inc.php.tmp：Code Content
  1. <?php
  2. /**
  3.  * $Id$
  4.  *
  5.  * KnowledgeTree Community Edition
  6.  * Document Management Made Simple
  7.  * Copyright (C) 2008 KnowledgeTree Inc.
  8.  * Portions copyright The Jam Warehouse Software (Pty) Limited
  9.  * 
  10.  * This program is free software; you can redistribute it and/or modify it under
  11.  * the terms of the GNU General Public License version 3 as published by the
  12.  * Free Software Foundation.
  13.  * 
  14.  * This program is distributed in the hope that it will be useful, but WITHOUT
  15.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16.  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  17.  * details.
  18.  * 
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21.  * 
  22.  * You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco, 
  23.  * California 94120-7775, or email info@knowledgetree.com.
  24.  * 
  25.  * The interactive user interfaces in modified source and object code versions
  26.  * of this program must display Appropriate Legal Notices, as required under
  27.  * Section 5 of the GNU General Public License version 3.
  28.  * 
  29.  * In accordance with Section 7(b) of the GNU General Public License version 3,
  30.  * these Appropriate Legal Notices must retain the display of the "Powered by
  31.  * KnowledgeTree" logo and retain the original copyright notice. If the display of the 
  32.  * logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
  33.  * must display the words "Powered by KnowledgeTree" and retain the original 
  34.  * copyright notice.
  35.  * Contributor( s): ______________________________________
  36.  */
  38. // more advanced, intelligent columns.
  40. require_once(KT_LIB_DIR . '/browse/advancedcolumns.inc.php');
  42. class AdvancedTitleColumn extends AdvancedColumn {
  43.     var $name = 'title';
  44.     var $namespace = 'ktcore.columns.title';
  45.     var $sortable = true;
  46.     var $aOptions = array();
  47.     var $aIconPaths = array();
  48.     var $link_folders = true;
  49.     var $link_documents = true;
  51.     function setOptions($aOptions) {
  52.         $this->link_folders = KTUtil::arrayGet($aOptions, 'link_folders', $this->link_folders, false);
  53.         $this->link_documents = KTUtil::arrayGet($aOptions, 'link_documents', $this->link_documents, false);
  54.         parent::setOptions($aOptions);
  55.     }
  57.     function AdvancedTitleColumn() {
  58.         $this->label = _kt("Title");
  59.     }
  61.     // what is used for sorting
  62.     // query addition is:
  63.     //    [0] => join claus
  64.     //    [1] => join params
  65.     //    [2] => ORDER
  67.     function addToFolderQuery() {
  68.         return array(null,
  69.             null,
  70.             "F.name",
  71.         );
  72.     }
  73.     function addToDocumentQuery() {
  74.             return array(null,
  75.             null,
  76.             "DM.name"
  77.         );
  78.     }
  81.     function renderFolderLink($aDataRow) {
  82.         /* this check has to be done so that any titles longer than 40 characters is not displayed incorrectly.
  83.          as mozilla cannot wrap text without white spaces */
  84.         if (mb_strlen($aDataRow["folder"]->getName(), 'UTF-8') > 40) {
  85.          mb_internal_encoding("UTF-8");
  86.             $outStr = htmlentities(mb_substr($aDataRow["folder"]->getName(), 0, 40, 'UTF-8')."...", ENT_NOQUOTES, 'UTF-8');
  87.         }else{
  88.             $outStr = htmlentities($aDataRow["folder"]->getName(), ENT_NOQUOTES, 'UTF-8');
  89.         }
  91.         if($this->link_folders) {
  92.             $outStr = '<a class="contenttype_href" href="' . $this->buildFolderLink($aDataRow) . '">' . $outStr . '</a>';
  93.         }
  94.         return $outStr;
  95.     }
  97.     function renderDocumentLink($aDataRow) {
  98.         /* this check has to be done so that any titles longer than 40 characters is not displayed incorrectly.
  99.          as mozilla cannot wrap text without white spaces */
  100.         if (mb_strlen($aDataRow["document"]->getName(), 'UTF-8') > 40) {
  101.          mb_internal_encoding("UTF-8");
  102.             $outStr = htmlentities(mb_substr($aDataRow["document"]->getName(), 0, 40, 'UTF-8')."...", ENT_NOQUOTES, 'UTF-8');
  103.         }else{
  104.             $outStr = htmlentities($aDataRow["document"]->getName(), ENT_NOQUOTES, 'UTF-8');
  105.         }
  107.         if($this->link_documents) {
  108.             $outStr = '<a href="' . $this->buildDocumentLink($aDataRow) . '" title="' . htmlentities($aDataRow["document"]->getFilename(), ENT_QUOTES, 'UTF-8').'">' .
  109.                 $outStr . '</a>';
  110.         }
  111.         return $outStr;
  112.     }
  114.     function buildDocumentLink($aDataRow) {
  115.      if($aDataRow['document']->isSymbolicLink()){
  116.      $iDocId = $aDataRow['document']->getRealDocumentId();
  117.      }else{
  118.      $iDocId = $aDataRow["document"]->getId();
  119.      }
  121.         $url = KTBrowseUtil::getUrlForDocument($iDocId);
  122.         if($aDataRow['document']->isSymbolicLink()){
  123.          $aDataRow['document']->switchToRealCore();
  124.          $url .= "&fShortcutFolder=".$aDataRow['document']->getFolderId();
  125.         }
  126.         return $url;
  127.     }
  130.     // 'folder_link' allows you to link to a different URL when you're connecting, instead of addQueryStringSelf
  131.     // 'direct_folder' means that you want to go to 'browse folder'
  132.     // 'qs_params' is an array (or string!) of params to add to the link
  134.     function buildFolderLink($aDataRow) {
  135.         if (is_null(KTUtil::arrayGet($this->aOptions, 'direct_folder'))) {
  136.            $dest = KTUtil::arrayGet($this->aOptions, 'folder_link');
  137.            if($aDataRow['folder']->isSymbolicLink()){
  138.             $params = array('fFolderId' => $aDataRow['folder']->getLinkedFolderId(),
  139.      'fShortcutFolder' => $aDataRow['folder']->getParentID());
  140.            }else{
  141.            $params = array('fFolderId' => $aDataRow['folder']->getId());
  142.            }
  143.     $params = kt_array_merge(KTUtil::arrayGet($this->aOptions, 'qs_params', array()),
  144.      $params);
  146.             if (empty($dest)) {
  147.                 return KTUtil::addQueryStringSelf($params);
  148.             } else {
  149.                 return KTUtil::addQueryString($dest, $params);
  150.             }
  152.         } else {
  153.          if($aDataRow['folder']->isSymbolicLink()){
  154.          return KTBrowseUtil::getUrlForFolder($aDataRow['folder']->getLinkedFolder())."&fShortcutFolder=".$aDataRow['folder']->getParentID();
  155.          }else{
  156.              return KTBrowseUtil::getUrlForFolder($aDataRow['folder']);
  157.          }
  158.         }
  159.     }
  161.     // use inline, since its just too heavy to even _think_ about using smarty.
  162.     function renderData($aDataRow) {
  163.        if ($aDataRow["type"] == "folder") {
  164.            $contenttype = 'folder';
  165.            $link = $this->renderFolderLink($aDataRow);
  166.            if($aDataRow['folder']->isSymbolicLink()){
  167.             return sprintf('<span class="contenttype %s">%s<img src="resources/tango-icons/shortcut.png" /></span>', $contenttype, $link);
  168.            }else{
  169.             return sprintf('<span class="contenttype %s">%s</span>', $contenttype, $link);
  170.            }
  171.         } else {
  172.          $contenttype = $this->_mimeHelper($aDataRow["document"]->getMimeTypeId());
  173.             $link = $this->renderDocumentLink($aDataRow);
  174.            
  175.             //Render an image instead of the size in case of a shortcut
  176.            if($aDataRow['document']->isSymbolicLink()){           
  177.             return sprintf('<span class="contenttype %s">%s <img src="resources/tango-icons/shortcut.png" /></span>', $contenttype, $link);
  178.            }else{
  179.             $size = $this->prettySize($aDataRow["document"]->getSize());
  180.             return sprintf('<span class="contenttype %s">%s (%s)</span>', $contenttype, $link, $size);
  181.            }
  182.         }
  183.     }
  185.     function prettySize($size) {
  186.         $finalSize = $size;
  187.         $label = 'b';
  189.         if ($finalSize > 1000) { $label='Kb'; $finalSize = floor($finalSize/1000); }
  190.         if ($finalSize > 1000) { $label='Mb'; $finalSize = floor($finalSize/1000); }
  191.         return $finalSize . $label;
  192.     }
  194.     function _mimeHelper($iMimeTypeId) {
  195.         require_once(KT_LIB_DIR . '/mime.inc.php');
  196.         return KTMime::getIconPath($iMimeTypeId);
  197.     }
  198. }
  200. /*
  201.  * Column to handle dates
  202.  */
  204. class AdvancedDateColumn extends AdvancedColumn {
  205.     var $name = 'datecolumn';
  207.     var $document_field_function;
  208.     var $folder_field_function;
  209.     var $sortable = true;
  210.     var $document_sort_column;
  211.     var $folder_sort_column;
  212.     var $namespace = 'ktcore.columns.genericdate';
  214.     function AdvancedDateColumn() {
  215.         $this->label = _kt('Generic Date Function');
  216.     }
  218.     // use inline, since its just too heavy to even _think_ about using smarty.
  219.     function renderData($aDataRow) {
  220.         $outStr = '';
  221.         if (($aDataRow["type"] == "folder") && (!is_null($this->folder_field_function))) {
  222.             $res = call_user_func(array($aDataRow["folder"],  $this->folder_field_function));
  223.             $dColumnDate = strtotime($res);
  225.             // now reformat this into something "pretty"
  226.             return date("Y-m-d H:i", $dColumnDate);
  228.         } else if (($aDataRow["type"] == "document") && (!is_null($this->document_field_function))) {
  229.             $res = call_user_func(array($aDataRow["document"],  $this->document_field_function));
  230.             $dColumnDate = strtotime($res);
  232.             // now reformat this into something "pretty"
  233.             return date("Y-m-d H:i", $dColumnDate);
  234.         } else {
  235.             return '&mdash;';
  236.         }
  237.         return $outStr;
  238.     }
  240.     function addToFolderQuery() {
  241.         return array(null, null, null);
  242.     }
  243.     function addToDocumentQuery() {
  244.         return array(null, null, $this->document_sort_column);
  245.     }
  246. }
  248. class CreationDateColumn extends AdvancedDateColumn {
  249.     var $document_field_function = 'getCreatedDateTime';
  250.     var $folder_field_function = null;
  252.     var $document_sort_column = "D.created";
  253.     var $folder_sort_column = null;
  254.     var $namespace = 'ktcore.columns.creationdate';
  256.     function CreationDateColumn() {
  257.         $this->label = _kt('Created');
  258.     }
  259. }
  261. class ModificationDateColumn extends AdvancedDateColumn {
  262.     var $document_field_function = 'getLastModifiedDate';
  263.     var $folder_field_function = null;
  265.     var $document_sort_column = "D.modified";
  266.     var $folder_sort_column = null;
  267.     var $namespace = 'ktcore.columns.modificationdate';
  269.     function ModificationDateColumn() {
  270.         $this->label = _kt('Modified');
  271.     }
  272. }
  274. class AdvancedUserColumn extends AdvancedColumn {
  275.     var $document_field_function;
  276.     var $folder_field_function;
  277.     var $sortable = false; // by default
  278.     var $document_sort_column;
  279.     var $folder_sort_column;
  280.     var $namespace = 'ktcore.columns.genericuser';
  282.     function AdvancedUserColumn() {
  283.         $this->label = null; // abstract.
  284.     }
  286.     // use inline, since its just too heavy to even _think_ about using smarty.
  287.     function renderData($aDataRow) {
  288.         $iUserId = null;
  289.         if (($aDataRow["type"] == "folder") && (!is_null($this->folder_field_function))) {
  290.             if (method_exists($aDataRow['folder'], $this->folder_field_function)) {
  291.                 $iUserId = call_user_func(array($aDataRow['folder'], $this->folder_field_function));
  292.             }
  293.         } else if (($aDataRow["type"] == "document") && (!is_null($this->document_field_function))) {
  294.             if (method_exists($aDataRow['document'], $this->document_field_function)) {
  295.                 $iUserId = call_user_func(array($aDataRow['document'], $this->document_field_function));
  296.             }
  297.         }
  298.         if (is_null($iUserId)) {
  299.             return '&mdash;';
  300.         }
  301.         $oUser = User::get($iUserId);
  302.         if (PEAR::isError($oUser) || $oUser == false) {
  303.             return '&mdash;';
  304.         } else {
  305.             return htmlentities($oUser->getName(), ENT_NOQUOTES, 'UTF-8');
  306.         }
  307.     }
  309.     function addToFolderQuery() {
  310.         return array(null, null, null);
  311.     }
  313.     function addToDocumentQuery() {
  314.         return array(null, null, null);
  315.     }
  316. }
  318. class CreatorColumn extends AdvancedUserColumn {
  319.     var $document_field_function = "getCreatorID";
  320.     var $folder_field_function = "getCreatorID";
  321.     var $sortable = true; // by default
  322.     var $namespace = 'ktcore.columns.creator';
  324.     function CreatorColumn() {
  325.         $this->label = _kt("Creator"); // abstract.
  326.     }
  327. }
  329. class AdvancedSelectionColumn extends AdvancedColumn {
  330.     var $rangename = null;
  331.     var $show_folders = true;
  332.     var $show_documents = true;
  334.     var $namespace = "ktcore.columns.selection";
  336.     function AdvancedSelectionColumn() {
  337.         $this->label = '';
  338.     }
  340.     function setOptions($aOptions) {
  341.         AdvancedColumn::setOptions($aOptions);
  342.         $this->rangename = KTUtil::arrayGet($this->aOptions, 'rangename', $this->rangename);
  343.         $this->show_folders = KTUtil::arrayGet($this->aOptions, 'show_folders', $this->show_folders, false);
  344.         $this->show_documents = KTUtil::arrayGet($this->aOptions, 'show_documents', $this->show_documents, false);
  345.     }
  347.     function renderHeader($sReturnURL) {
  348.         global $main;
  349.         $main->requireJSResource("resources/js/toggleselect.js");
  351.         return sprintf('<input type="checkbox" title="toggle all" onclick="toggleSelectFor(this, '%s')" />', $this->rangename);
  353.     }
  355.     // only include the _f or _d IF WE HAVE THE OTHER TYPE.
  356.     function renderData($aDataRow) {
  357.         $localname = htmlentities($this->rangename,ENT_QUOTES,'UTF-8');
  359.         if (($aDataRow["type"] === "folder") && ($this->show_folders)) {
  360.             if ($this->show_documents) {
  361.                 $localname .= "_f[]";
  362.             }
  363.             $v = $aDataRow["folderid"];
  364.         } else if (($aDataRow["type"] === "document") && $this->show_documents) {
  365.             if ($this->show_folders) {
  366.                 $localname .= "_d[]";
  367.             }
  368.             $v = $aDataRow["docid"];
  369.         } else {
  370.             return '&nbsp;';
  371.         }
  373.         return sprintf('<input type="checkbox" name="%s" onclick="activateRow(this)" value="%s"/>', $localname, $v);
  374.     }
  377.     // no label, but we do have a title
  378.     function getName() {
  379.         return _kt("Multiple Selection");
  380.     }
  381. }
  384. class AdvancedSingleSelectionColumn extends AdvancedSelectionColumn {
  385.     var $namespace = 'ktcore.columns.singleselection';
  387.     function AdvancedSingleSelectionColumn() {
  388.         parent::AdvancedSelectionColumn();
  389.         $this->label = null;
  390.     }
  392.     function renderHeader() {
  393.      global $main;
  394.         //include some javascript to force real single selections
  395.         if($this->show_folders && $this->show_documents){
  396.          $main->requireJSResource("resources/js/singleselect.js");
  397.         }
  398.         return '&nbsp;';
  399.     }
  401.     // only include the _f or _d IF WE HAVE THE OTHER TYPE.
  402.     function renderData($aDataRow) {
  403.         $localname = $this->rangename;
  405.         if (($aDataRow["type"] === "folder") && ($this->show_folders)) {
  406.             if ($this->show_documents) {
  407.                 $localname .= "_f";
  408.             }
  409.             $v = $aDataRow["folderid"];
  410.         } else if (($aDataRow["type"] === "document") && $this->show_documents) {
  411.             if ($this->show_folders) {
  412.                 $localname .= "_d";
  413.             }
  414.             $v = $aDataRow["docid"];
  415.         } else {
  416.             return '&nbsp;';
  417.         }
  419.         $return =  '<input type="radio" name="' . $localname . '" value="' . $v . '" ';  
  420.         if($this->show_folders && $this->show_documents){
  421.          $return .= 'onClick="forceSingleSelect(this)" ';
  422.         }
  423.         $return .='/>';
  424.         return $return;
  425.     }
  427.     // no label, but we do have a title
  428.     function getName() {
  429.         return _kt("Single Selection");
  430.     }
  431. }
  434. class AdvancedWorkflowColumn extends AdvancedColumn {
  435.     var $namespace = 'ktcore.columns.workflow_state';
  436.     var $sortable = false;
  438.     function AdvancedWorkflowColumn() {
  439.         $this->label = _kt("Workflow State");
  440.         $this->sortable = false;
  441.     }
  443.     // use inline, since its just too heavy to even _think_ about using smarty.
  444.     function renderData($aDataRow) {
  445.         // only _ever_ show this for documents.
  446.         if ($aDataRow["type"] === "folder") {
  447.             return '&nbsp;';
  448.         }
  450.         $oWorkflow = KTWorkflowUtil::getWorkflowForDocument($aDataRow['document']);
  451.         $oState = KTWorkflowUtil::getWorkflowStateForDocument($aDataRow['document']);
  452.         if (($oState == null) || ($oWorkflow == null)) {
  453.             return '&mdash;';
  454.         } else {
  455.             return sprintf('%s <span class="descriptive">%s</span>',
  456.                 htmlentities($oState->getName(), ENT_NOQUOTES, 'UTF-8'),
  457.                 htmlentities($oWorkflow->getName(), ENT_NOQUOTES, 'UTF-8')
  458.             );
  459.         }
  460.     }
  461. }
  463. class CheckedOutByColumn extends AdvancedColumn {
  464.     var $namespace = 'ktcore.columns.checkedout_by';
  465.     var $sortable = false;
  467.     function CheckedOutByColumn() {
  468.         $this->label = _kt('Checked Out By');
  469.         $this->sortable = false;
  470.     }
  472.     function renderData($aDataRow) {
  473.         // only show this for documents.
  474.         if ($aDataRow['type'] === 'folder') {
  475.             return '&nbsp;';
  476.         }
  478.         // Check if document is checked out
  479.         $bIsCheckedOut = $aDataRow['document']->getIsCheckedOut();
  481.         if($bIsCheckedOut){
  482.             // Get the user id
  483.             $iUserId = $aDataRow['document']->getCheckedOutUserID();
  484.             $oUser = User::get($iUserId);
  485.             $sUser = $oUser->getName();
  487.             return '<span class="descriptive">'.htmlentities($sUser, ENT_NOQUOTES, 'UTF-8').'</span>';
  488.         }
  489.         return '&mdash;';
  490.     }
  491. }
  493. class DocumentTypeColumn extends AdvancedColumn {
  494.     var $namespace = 'ktcore.columns.document_type';
  495.     var $sortable = false;
  497.     function DocumentTypeColumn() {
  498.         $this->label = _kt('Document Type');
  499.         $this->sortable = false;
  500.     }
  502.     function renderData($aDataRow) {
  503.         // only show this for documents.
  504.         if ($aDataRow['type'] === 'folder') {
  505.             return '&nbsp;';
  506.         }
  508.         // Check if document is checked out
  509.         $iDocTypeId = $aDataRow['document']->getDocumentTypeID();
  511.         if(!empty($iDocTypeId)){
  512.             $oDocumentType = DocumentType::get($iDocTypeId);
  513.             $sType = $oDocumentType->getName();
  515.             return '<span class="descriptive">'.htmlentities($sType, ENT_NOQUOTES, 'UTF-8').'</span>';
  516.         }
  517.         return '&mdash;';
  518.     }
  519. }
  521. class AdvancedDownloadColumn extends AdvancedColumn {
  523.     var $namespace = 'ktcore.columns.download';
  525.     function AdvancedDownloadColumn() {
  526.         $this->label = null;
  527.     }
  529.     function renderHeader($sReturnURL) {
  530.         return '&nbsp;';
  531.     }
  533.     function renderData($aDataRow) {
  534.         // only _ever_ show this for documents.
  535.         if ($aDataRow["type"] === "folder") {
  536.             return '&nbsp;';
  537.         }
  539.         $link = KTUtil::ktLink('action.php','ktcore.actions.document.view', 'fDocumentId=' . $aDataRow['document']->getId());
  540.         return sprintf('<a href="%s" class="ktAction ktDownload" title="%s">%s</a>', $link, _kt('Download Document'), _kt('Download Document'));
  541.     }
  543.     function getName() { return _kt('Download'); }
  544. }
  547. class DocumentIDColumn extends AdvancedColumn {
  548.     var $bSortable = false;
  549.     var $namespace = 'ktcore.columns.docid';
  551.     function DocumentIDColumn() {
  552.         $this->label = _kt("Document ID");
  553.     }
  555.     function renderData($aDataRow) {
  556.         // only _ever_ show this for documents.
  557.         if ($aDataRow["type"] === "folder") {
  558.             return '&nbsp;';
  559.         }
  561.         return htmlentities($aDataRow['document']->getId(), ENT_NOQUOTES, 'UTF-8');
  562.     }
  563. }
  565. class ContainingFolderColumn extends AdvancedColumn {
  567.     var $namespace = 'ktcore.columns.containing_folder';
  569.     function ContainingFolderColumn() {
  570.         $this->label = _kt("View Folder");
  571.     }
  573.     function renderData($aDataRow) {
  574.         // only _ever_ show this for documents.
  575.         if ($aDataRow["type"] === "folder") {
  576.             return '&nbsp;';
  577.         }
  579.         $link = KTBrowseUtil::getUrlForFolder($aDataRow['document']->getFolderId());
  580.         return sprintf('<a href="%s" class="ktAction ktMoveUp" title="%s">%s</a>', $link, _kt('View Folder'), _kt('View Folder'));
  581.     }
  583.     function getName() { return _kt('Opening Containing Folder'); }
  584. }
  586. ?>