data_source.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset.inc';
require_once SQ_CORE_PACKAGE_PATH.'/interfaces/bridge/bridge.inc';

class Data_Source extends Asset implements Bridge
{


    function __construct($assetid=0)
    {
        $this->_ser_attrs = TRUE;
        parent::__construct($assetid);

    }//end constructor


    protected function _createAdditional(Array &$link)
    {
        if (!parent::_createAdditional($link)) return FALSE;

        // set an initial web path
        $initial_path = strtolower($this->attr('name'));
        require_once SQ_INCLUDE_PATH.'/general_occasional.inc';
        $valid_paths = make_valid_web_paths(Array($initial_path));
        $good_paths = $GLOBALS['SQ_SYSTEM']->am->webPathsInUse($link['asset'], $valid_paths, $this->id, TRUE);
        return $this->saveWebPaths($good_paths);

    }//end _createAdditional()


    protected function _getName($short_name=FALSE, $contextid=NULL)
    {
        // No context specified, using the current context
        if ($contextid === NULL) {
            $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();
        }//end if

        // Obtain the attribute value for Name from the specified Context
        $values = $GLOBALS['SQ_SYSTEM']->am->getAttributeValuesByName('name', $this->type(), Array($this->id), $contextid);
        if (empty($values) === TRUE) {
            return parent::_getName($short_name, $contextid);
        } else {
            return $values[$this->id];
        }

    }//end _getName()


    public function _getAllowedLinks()
    {
        return Array();

    }//end _getAllowedLinks()


    public function getFieldNamesFromRecordSet()
    {
        return Array();

    }//end getFieldNamesFromRecordSet()


    public function getResultSet($result_id='')
    {
        return $this->getCachedResultSet($result_id);

    }//end getResultSet()


    public function getCachedResultSet($cache_key='')
    {
        $cm = $GLOBALS['SQ_SYSTEM']->am->getSystemAsset('cache_manager');
        $result = $cm->loadFromCache($this->id, $this->type(), $cache_key, FALSE);

        // empty string means that the result was not serialised
        // which means cache manager does not have an entry for this cache_key
        if ($result === FALSE) return FALSE;

        $result = unserialize($result);
        return $result;

    }//end getCachedResultSet()


    public function setResultSet(Array $result, $result_id='')
    {
        $this->cacheResultSet($result, $result_id);

    }//end setResultSet()


    public function cacheResultSet(Array $result, $cache_key='')
    {
        if (!empty($cache_key)) {
            $this->setAttrValue('cache_key', $cache_key);
        }

        $cm = $GLOBALS['SQ_SYSTEM']->am->getSystemAsset('cache_manager');
        $r = $cm->saveToCache($this->id, $this->type(), $cache_key, serialize($result), FALSE);

    }//end cacheResultSet()


    public function getPermission($assetid, $permission, $granted=NULL, $and_greater=TRUE, $expand_groups=FALSE, $all_info=FALSE)
    {
        return Array();

    }//end getPermission()


    public function setPermission($assetid, $data_source_record_setid, $permission, $granted)
    {
        return FALSE;

    }//end setPermission()


    public function deletePermission($assetid, $data_source_record_setid, $permission)
    {
        return FALSE;

    }//end deletePermission()


    public function getAssetInfo(Array $assetids, $type_code=Array(), $strict_type_code=TRUE, $field='')
    {
        $info = Array();
        foreach ($assetids as $assetid) {
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
            $keywords = $asset->getAvailableKeywords();
            // if a sort field is specified then return only that field value else return all of the fields
            if (!empty($field)) {
                if ($field === 'type_code') {
                    $info[$assetid] = $asset->type();
                } else if (isset($asset->{$field})) {
                    $info[$assetid] = $asset->{$field};
                } else {
                    trigger_error('Invalid sort field for the asset type Data Source Record Set', E_USER_ERROR);
                }
            } else {
                $info[$assetid] = Array(
                                    'type_code'             => 'data_source_record_set',
                                    'version'               => $asset->version,
                                    'name'                  => $asset->name,
                                    'short_name'            => $asset->short_name,
                                    'status'                => $asset->status,
                                    'languages'             => '',
                                    'charset'               => '',
                                    'force_secure'          => '0',
                                    'created'               => $asset->getKeywordReplacement('asset_created'),
                                    'created_userid'        => $asset->created_userid,
                                    'updated'               => $asset->getKeywordReplacement('asset_updated'),
                                    'updated_userid'        => $asset->updated_userid,
                                    'published'             => $asset->getKeywordReplacement('asset_published'),
                                    'published_userid'      => $asset->published_userid,
                                    'status_changed'        => $asset->getKeywordReplacement('asset_status_changed'),
                                    'status_changed_userid' => $asset->status_changed_userid,
                                  );
            }//end if field not empty
        }//end foreach of assetids
        return $info;

    }//end getAssetInfo()


    public function assetExists($assetids)
    {
        return FALSE;

    }//end assetExists()


    public function getLink($assetid, $link_type=NULL, $type_code='', $strict_type_code=TRUE, $value=NULL, $side_of_link='major', $exclusive=NULL)
    {
        return Array();

    }//end getLink()


    public function getLinkById($linkid, $assetid=0, $side_of_link='major')
    {
        return Array();

    }//end getLinkById()


    public function countLinks($assetid, $side_of_link='major', $link_types=0, $type_code='', $strict_type_code=TRUE, $ignore_linkid=0)
    {
        return 0;

    }//end countLinks()


    public function getLinkByAsset($assetid, $other_assetid, $link_types=NULL, $value=NULL, $side_of_link='major', $force_array=FALSE, $dependant=NULL, $exclusive=NULL)
    {
        return Array();

    }//end getLinkByAsset()


    public function getAllChildLinks($assetid, $link_type=0)
    {
        return Array();

    }//end getAllChildLinks()

    
    function getBinaryDataAttributes()
    {
        return Array();

    }//end getBinaryDataAttributes()

    
    public function updateLink($linkid, $link_type=NULL, $value=NULL, $sort_order=NULL)
    {
        return FALSE;

    }//end updateLink()


    public function deleteAssetLink($linkid, $moving=FALSE)
    {
        return FALSE;

    }//end deleteAssetLink()


    public function createAssetLink(Asset $major, Asset $minor, $link_type, $value='', $sort_order=NULL, $dependant='0', $exclusive='0', $moving=FALSE)
    {
        return 0;

    }//end createAssetLink()


    public function getLinks($assetid, $link_types, $type_code='', $strict_type_code=TRUE, $side_of_link='major', $sort_by=NULL)
    {
        if (!($link_types & SQ_LINK_TYPE_1)) {
            return Array();
        }

        if (!is_array($type_code)) {
            if (empty($type_code)) {
                $type_code = Array();
            } else {
                $type_code = Array($type_code);
            }
        }
        $type_code_key = implode('-', $type_code);
        $links = Array();

        if ($side_of_link == 'major') {
            if ($assetid == $this->id) {
                $result = $this->filterResultSet($this->getResultSet());
                if (empty($result)) {
                    return Array();
                } else {
                    $identity = 0;
                    $index = 0;
                    foreach ($result as $record) {
                        $links[] = Array(
                                    'linkid'            => 0,
                                    'majorid'           => $this->id,
                                    'minorid'           => $this->id.':'.$identity,
                                    'minor_type_code'   => 'data_source_record_set',
                                    'value'             => '',
                                    'link_type'         => SQ_LINK_TYPE_1,
                                    'is_dependant'      => FALSE,
                                    'is_exclusive'      => FALSE,
                                    'sort_order'        => $index,
                                    'locked'            => 0,
                                   );
                        $index++;
                        $identity++;
                    }
                }
            } else {
                $links = Array();
            }
        }
        
        return $links;

    }//end getLinks()


    public function getChildren($assetid, $type_code='', $strict_type_code=TRUE, $dependant=NULL, $sort_by=NULL)
    {
        // now that we have an array in the format we wanted (sorted or not)
        // we can go through and construct our children array
        $children = Array();
        $links = Array();
        if ($assetid == $this->id) {
            $links = $this->getLinks($this->id, SQ_LINK_TYPE_1, 'data_source_record_set', TRUE, 'major', NULL);
        }
        if (!empty($links)) {
            foreach ($links as $link) {
                $children[$link['minorid']][0]['type_code'] = $link['minor_type_code'];
            }
        }
        return $children;

    }//end getChildren()


    public function getAsset($assetid, $type_code='', $mute_errors=FALSE, $return_null=FALSE)
    {
        $shadowid = explode(':', $assetid);
        $shadowid = array_pop($shadowid);
        $asset = NULL;
        if (is_null($shadowid)) return $asset;
        $result = $this->filterResultSet($this->getResultSet());

        if (!empty($result)) {
            if (isset($result[$shadowid])) {
                $record = $result[$shadowid];
                $record['shadow_asset_name'] = $this->attr('shadow_name');
                $record['shadow_asset_id'] = $shadowid;
                $GLOBALS['SQ_SYSTEM']->am->includeAsset('data_source_record_set');
                $asset = new Data_Source_Record_Set($this->id, $record);
            }
        }
        
        if(is_null($asset)) {
            return $return_null ? NULL : $this->_getDummyAsset($shadowid);
        } else {
            return $asset;
        }

    }//end getAsset()

    
    protected function _getDummyAsset($shadowid){
        
        $record['shadow_asset_name'] = 'Unknown Data Source Record';
        $record['shadow_asset_id'] = $shadowid;
        $GLOBALS['SQ_SYSTEM']->am->includeAsset('data_source_record_set');
        $asset = new Data_Source_Record_Set($this->id, $record);
        return $asset;
        
    }//end _getDummyAsset()
    
    
    public function getParents($assetid, $type_code='', $strict_type_code=TRUE, $sort_by=NULL, $access=NULL)
    {
        // get its own (datasource's) parents first
        $id_parts = explode(':', $assetid);
        $parents = $GLOBALS['SQ_SYSTEM']->am->getParents($id_parts[0]);
        // after getting its own parent, the data soure adds itself as a pareent into the array as the shadow asset is its child
        $parents[$this->id] = $this->type();
        return $parents;

    }//end getParents()


    public function getAssetMapAssetInfo($assetid)
    {
        return Array();

    }//end getAssetMapAssetInfo()


    public function getLineageFromURL($assetid, $protocol, $url)
    {
        return Array();

    }//end getLineageFromURL()
    
    
    function filterResultSet($result)
    {
        if (!$this->attr('filter_enabled')) {
            return $result;
        }
        $filters = $this->getDatasourceFilters();
        if (empty($filters)) {
            return $result;
        }
        
        $grouping_logic = $this->attr('filter_logic');
        $filter_mode = $this->attr('filter_mode');
        
        // Check the cache
        $hash = md5($this->attr('cache_key').$grouping_logic.$filter_mode.serialize($filters));
        if (isset($this->tmp[$hash])) {
            return $this->tmp[$hash];
        }
        $cached_result = $this->getCachedResultSet($hash);
        if ($cached_result !== FALSE) {
            $this->tmp[$hash] = $cached_result;
            return $cached_result;
        }

        $filtered_result = Array();
        foreach($result as $index => $recordset) {
            $condition_matched = TRUE;
            foreach($filters as $filter) {
                $field_name = $filter['name'];
                $field_value = $filter['value'];
                $match_type = $filter['match_type'];
                $match_case = $filter['match_case'];
                if (!isset($recordset[$field_name])) {
                    continue;
                }
                
                $record_value = trim($recordset[$field_name]);
                $condition_matched = FALSE;
                switch($match_type) {
                    case 'contains':
                        if ($match_case == 'ignore_case') {
                            $condition_matched = stripos($record_value, $field_value) !== FALSE;
                        } else {
                            $condition_matched = strpos($record_value, $field_value) !== FALSE;
                        }
                    break;

                    case 'exact':
                        if ($match_case == 'ignore_case') {
                            $condition_matched = strtolower($record_value) == strtolower($field_value);
                        } else {
                            $condition_matched = $record_value == $field_value;
                        }
                    break;

                    case 'regex':
                        $condition_matched = preg_match('/'.str_replace('/', '\/',$field_value).'/'.($match_case == 'ignore_case' ? 'i' : ''), $record_value);
                    break;
                }//end switch
                
                // Allow empty string comparision
                if (!$condition_matched && empty($record_value) && empty($field_value)) {
                    $condition_matched = TRUE;
                }

                if ($grouping_logic == 'OR' && $condition_matched) {
                    break;
                } else if ($grouping_logic == 'AND' && !$condition_matched) {
                    break;
                }

            }//end foreach

            if ($condition_matched && $filter_mode == 'include') {
                $filtered_result[] = $recordset;
            } else if (!$condition_matched && $filter_mode == 'exclude') {
                $filtered_result[] = $recordset;
            }
            
        }//end foreach

        // Cache the result
        $this->cacheResultSet($filtered_result, $hash);
        $this->tmp[$hash] = $filtered_result;

        return $filtered_result;

    }//end filterRecordSet()


    
    function getDatasourceFilters()
    {
        $filters = $this->attr('record_filters');
        if (empty($filters)) {
            return Array();
        }
        
        // Keyword pattern for the dynamic keyword 
        $keyword_pattern = '('.'%%'.'([a-zA-Z_\-0-9\.]+)'.'%%'.')';

        foreach($filters as $index => $filter)  {
            if (empty($filter['name'])) {
                continue;
            }
            // Replace the dynamic keyword in the filter's value
            $filter_val = $filter['value'];
            preg_match_all ('/'.$keyword_pattern.'/', $filter_val, $matches, PREG_PATTERN_ORDER);

            foreach($matches[2] as $keyword) {
                $value = $this->getDynamicVariableValue($keyword);
                $filter_val = str_replace('%%'.$keyword.'%%', $value, $filter_val);
            }//end foreach
            $filters[$index]['value'] = $filter_val;
        }//end foreach

        return $filters;

    }//end getDatasourceFilters()
    
    
    function getDynamicVariableValue($variable_name)
    {
        $dynamic_vars = $this->attr('dynamic_vars');
        if (!isset($dynamic_vars[$variable_name])) return '';

        $parameter_map = $this->getAttribute('parameter_map');
        $value = $parameter_map->getParameterValue($variable_name);

        if (empty($value)) {
            $value = array_get_index($dynamic_vars, $variable_name, '');
        }

        return $value;

    }//end getDynamicVariableValue()

    function delete($release_lock)
    {
        if (parent::delete($release_lock)) {
            $this->_deleteStoredContents();
            return TRUE;
        }

        return FALSE;

    }//end delete()


    function _deleteStoredContents()
    {

        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        $sql = 'DELETE FROM sq_shdw_ast_lnk WHERE minorid LIKE :minorid';

        $query = MatrixDAL::preparePdoQuery($sql);
        MatrixDAL::bindValueToPdo($query, 'minorid', $this->id.':%');
        $result = MatrixDAL::execPdoQuery($query);

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end _deleteStoredContents()
    
}//end class

?>