cron_job_future_permission.inc

<?php
require_once SQ_CORE_PACKAGE_PATH.'/system/cron/cron_job/cron_job.inc';

class Cron_Job_Future_Permission extends Cron_Job
{


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

    }//end constructor


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

        if (!empty($this->_tmp['asset_in_link'])) {
            if (!$GLOBALS['SQ_SYSTEM']->am->acquireLock($this->id, 'links')) {
                trigger_localised_error('CRON0059', E_USER_WARNING);
                return FALSE;
            }

            $link = $this->_tmp['asset_in_link'];
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($link['minorid'], $link['minor_type_code']);
            if (is_null($asset) || !$this->setAssetToUpdate($asset)) {
                trigger_localised_error('CRON0060', E_USER_WARNING);
                return FALSE;
            }

            unset($this->_tmp['asset_in_link']);
            $GLOBALS['SQ_SYSTEM']->am->releaseLock($this->id, 'links');
        }
        return TRUE;

    }//end _createAdditional()


    protected function _getName($short_name=FALSE)
    {
        $asset = $this->getAssetToUpdate();
        if (is_null($asset)) {
            return translate('cron_job_asset_less_future_permission');
        } else if ($short_name) {
            return translate('cron_fp_for', translate('asset_format', $asset->short_name, $asset->id));
        } else {
            return translate('cron_future_permission_for', translate('asset_format', $asset->name, $asset->id));
        }

    }//end _getName()


    public function _getAllowedLinks()
    {
        $links = parent::_getAllowedLinks();

        // make sure that we can link to every asset
        if (empty($links[SQ_LINK_NOTICE]['asset'])) {
            $links[SQ_LINK_NOTICE]['asset'] = Array('card' => 1);
        }

        return $links;

    }//end _getAllowedLinks()


    public function canDelete()
    {
        if (parent::canDelete()) return TRUE;

        // read-only?
        if ($this->attr('read_only')) return FALSE;

        $asset = $this->getAssetToUpdate();
        if (!is_null($asset)) return $asset->adminAccess('');
        return FALSE;

    }//end canDelete()


    public function setAttrValue($name, $value)
    {
        switch ($name) {
            case 'permission' :
                $value = (int) $value;
                if (!in_array($value, $this->_getAllPermissions())) {
                    trigger_localised_error('CRON0061', E_USER_NOTICE);
                    return FALSE;
                }
            break;

            case 'type' :
                trigger_localised_error('CRON0062', E_USER_NOTICE);
                return FALSE;
            break;
        }//end if

        return parent::setAttrValue($name, $value);

    }//end setAttrValue()


    protected static function _getAllPermissions()
    {
        return Array('read' => SQ_PERMISSION_READ, 'write' => SQ_PERMISSION_WRITE, 'admin' => SQ_PERMISSION_ADMIN);
        
    }//end _getAllPermissions()


    public static function getAllPermissionDescs()
    {
        static $descs = Array();

        if (empty($descs)) {
            $permissions = self::_getAllPermissions();
            foreach ($permissions as $name => $value) {
                $descs[$value] = ucfirst($name);
            }
        }

        return $descs;

    }//end getAllPermissionDescs()


    public function permissionName()
    {
        $descs = self::getAllPermissionDescs();
        return $descs[$this->attr('permission')];
        
    }//end permissionName()


    public function getGrantedUsers($grant = TRUE)
    {
        $grant_int = $grant? 1 : 0;
        $userid_grant_list = $this->attr('userids');
        $userids = Array();
        foreach ($userid_grant_list as $userid => $user_grant) {
            if ($user_grant == $grant_int) {
                $userids[] = $userid;
            }
        }
        
        return $userids;
        
    }//end getGrantedUsers()
    
    public function actionName()
    {
        return ($this->attr('add')? translate('add') : translate('remove'));
        
    }//end actionName()
    
    public function setAssetToUpdate(Asset $asset)
    {
        if ($this->id) {
            $existing_links = $GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_NOTICE, '', TRUE, 'major', $value='updating');
            $link_exists = FALSE;
            foreach ($existing_links as $old_link) {
                if ($old_link['minorid'] == $asset->id) {
                    $link_exists = TRUE;
                } else {
                    $GLOBALS['SQ_SYSTEM']->am->deleteAssetLink($old_link['linkid']);
                }
            }
            if ($link_exists) {
                return TRUE;
            } else {
                return (bool)  $this->createLink($asset, SQ_LINK_NOTICE, 'updating');
            }
        } else {
            if (!isset($this->_tmp['asset_in_link'])) {
                $this->_tmp['asset_in_link'] = Array();
            }
            $this->_tmp['asset_in_link'] = Array('minorid' => $asset->id, 'minor_type_code' => $asset->type());
            return TRUE;
        }

    }//end setAssetToUpdate()


    public function getAssetToUpdate()
    {
        // because we need to return by ref
        $null = NULL;

        if ($this->id) {
            $link = $GLOBALS['SQ_SYSTEM']->am->getLink($this->id, SQ_LINK_NOTICE, 'asset', FALSE, 'updating');
        } else {
            $link = (isset($this->_tmp['asset_in_link'])) ? $this->_tmp['asset_in_link'] : Array();
        }
        if (empty($link)) return $null;

        return $GLOBALS['SQ_SYSTEM']->am->getAsset($link['minorid'], $link['minor_type_code']);

    }//end getAssetToUpdate()


    protected function _exec(&$msg)
    {
        $asset = $this->getAssetToUpdate();
        if (!is_null($asset)) {
            $add_permissions = $this->attr('add');
            $permission = $this->attr('permission');
            $userid_grant_list = $this->attr('userids');
            $cascade_to_new = $this->attr('cascade_to_new');
            $previous_access = NULL;
            $dependants_only = $this->attr('dependants_only');
            $permission_vars = Array();
            foreach ($userid_grant_list as $userid => $user_grant) {
                $granted = $add_permissions? $user_grant : -1;
                if (!$add_permissions) {
                    $previous_access = $user_grant;
                }
                $permission_vars[] = Array(
                                                'permission'        => $permission,
                                                'assetids'          => Array($asset->id),
                                                'granted'           => $granted,
                                                'userid'            => $userid,
                                                'cascades'          => $cascade_to_new,
                                                'previous_access'   => $previous_access,
                                                'dependants_only'   => !(!$dependants_only && $cascade_to_new), //consistency with the permission screen logic
                                            );
            }

            $hh = $GLOBALS['SQ_SYSTEM']->getHipoHerder();
            $vars = Array(
                        'permission_changes'    => $permission_vars,
                    );
            $errors = $hh->freestyleHipo('hipo_job_edit_permissions', $vars);
            if (empty($errors)) {
                //success
                return SQ_CRON_JOB_COMPLETED | SQ_CRON_JOB_REMOVE;
            } else {
                // process failed
                trigger_localised_error('CRON0063', E_USER_WARNING, $asset->name, $asset->id);
            }

        } else {
            // asset not found
            trigger_localised_error('CRON0064', E_USER_WARNING);
        }

        // we can be removed because the error is beyound our control
        return SQ_CRON_JOB_ERROR | SQ_CRON_JOB_REMOVE;

    }//end _exec()


    public static function &getActiveJobs(Asset $asset)
    {
        $links = $GLOBALS['SQ_SYSTEM']->am->getLinks($asset->id, SQ_LINK_NOTICE, 'cron_job_future_permission', TRUE, 'minor', 'updating');
        $assetids = Array();
        foreach ($links as $link) {
            $assetids[] = $link['majorid'];
        }
        
        sort($assetids);
        
        $fp_jobs = Array();
        foreach ($assetids as $assetid) {
            $fp_jobs[] = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid, 'cron_job_future_permission');
        }
        
        return $fp_jobs;
        
    }//end getActiveJobs()


}//end class

?>