cron_job_attempt_safe_trash.inc

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

class Cron_Job_Attempt_Safe_Trash extends Cron_Job
{


    function __construct($assetid=0)
    {
        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('CRON0018', 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('CRON0017', 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_assetless_attempt_safe_trash');
        } else if ($short_name) {
            return translate('cron_safe_trash_for', translate('asset_format', $asset->short_name, $asset->id));
        } else {
            return translate('cron_attempt_safe_trash_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;

        // TODO: will this restriction be allowed too?
        $asset = $this->getAssetToUpdate();
        if (!is_null($asset)) return $asset->adminAccess('');
        return FALSE;

    }//end canDelete()


    public function setAttrValue($name, $value)
    {
        switch ($name) {
            case 'type' :
                trigger_localised_error('CRON0038', E_USER_NOTICE);
                return FALSE;
            break;
        }//end if

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

    }//end setAttrValue()


    public function setAssetToUpdate(Asset $asset)
    {
        if (!($asset instanceof Asset)) {
            trigger_localised_error('CRON0030', E_USER_WARNING);
            return FALSE;
        }

        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)) {

            // Can we safe trash?
            $safe_trash_enabled = $GLOBALS['SQ_SYSTEM']->getUserPrefs('user', 'SQ_USER_SAFE_TYPE3_TRASH');
            $safe_trash_errors = $GLOBALS['SQ_SYSTEM']->am->canSafeTrashAsset($asset->id);

            if ($safe_trash_enabled && !empty($safe_trash_errors)) {
               $msg = 'Cannot trash '.$asset->id;
               // We keep this job hanging around until we can delete it
               return SQ_CRON_JOB_COMPLETED;
            } else {
               $GLOBALS['SQ_SYSTEM']->am->trashAsset($asset->id);
               $msg = 'Successfully trashed '.$asset->id;
               // We can remove it now
               return SQ_CRON_JOB_COMPLETED | SQ_CRON_JOB_REMOVE;
            }

        } else {
            // asset not found
            trigger_localised_error('CRON0020', 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()


}//end class

?>