asset_status_live_approval.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset_status/asset_status.inc';

class Asset_Status_Live_Approval extends Asset_Status
{


    function Asset_Status_Live_Approval($owner)
    {
        $this->Asset_Status($owner);
        $this->status_tag = SQ_STATUS_LIVE_APPROVAL;

    }//end constructor


    public static function getDescription()
    {
        return translate('status_live_approval');

    }//end getDescription()


    function getAvailableStatii()
    {
        $statii = Array();

        // cant do anything without write access
        if (!$this->owner->readAccess()) return $statii;

        if ($this->owner->adminAccess('')) {
            $statii[SQ_STATUS_EDITING] = translate('status_change_safe_edit');
        }

        $wfm = $GLOBALS['SQ_SYSTEM']->getWorkflowManager();
        $running_schemas = $wfm->getSchemas($this->owner->id, true, true);

        if (!empty($running_schemas)) {
            $userid = $GLOBALS['SQ_SYSTEM']->currentUserId();

            // check to see if the user logged in can publish
            $publishers = $wfm->whoCanPublish($this->owner->id);

            // if nobody can publish we better let admins do it
            $admin_access = $this->owner->adminAccess('');

            if (in_array($userid, $publishers) || $admin_access) {
                // the current user can approve this asset to keep the workflow going
                $wf_complete = $wfm->testPublish($this->owner->id, $GLOBALS['SQ_SYSTEM']->currentUserId());

                // we also need to check what if all the required metadata fields are completed
                $mm = $GLOBALS['SQ_SYSTEM']->getMetadataManager();
                $is_dependant = $GLOBALS['SQ_SYSTEM']->am->isDependant($this->owner->id);
                
                if ($mm->allowsMetadata($this->owner->id)) {
                    $m_complete = $mm->requiredFieldsComplete($this->owner->id);
                    if ($wf_complete && ((!$is_dependant && $m_complete) || $is_dependant)) {
                        $statii[SQ_STATUS_LIVE] = translate('status_change_approve_and_make_live');
                    } else if (in_array($userid, $publishers)) {
                        $statii[SQ_STATUS_LIVE_APPROVAL] = translate('status_change_approve_review');
                    }
                } else {
                    // this asset needs to allow both statuses because it cant check metadata requirements
                    // due to it not allowing metadata
                    $statii[SQ_STATUS_LIVE] = translate('status_change_approve_and_make_live');
                    $statii[SQ_STATUS_LIVE_APPROVAL] = translate('status_change_approve_review');
                }

                $statii[SQ_STATUS_EDITING] = translate('status_change_safe_edit');
            }
        } else {
            // no running workflow means that anyone with admin access can
            // make this live (up for review is just a flag in this case)
            $statii[SQ_STATUS_LIVE] = translate('status_change_approve_and_make_live');
            if ($this->owner->adminAccess('')) {
                $statii[SQ_STATUS_ARCHIVED] = translate('status_change_archive');
            }       

        }//end if workflow running

        return $statii;

    }//end getAvailableStatii()


    function processStatusChange($new_status, $update_parent=true)
    {
        if (!parent::processStatusChange($new_status, $update_parent)) {
            return false;
        }

        $wfm = $GLOBALS['SQ_SYSTEM']->getWorkflowManager();
        $current_userid = $GLOBALS['SQ_SYSTEM']->currentUserId();

        if ($new_status == SQ_STATUS_EDITING) {

            $running_schemas = $wfm->getSchemas($this->owner->id, true, true);
            if (!empty($running_schemas)) {
                // someone has rejected the approval, so we need to cancel the workflow
                $user = $GLOBALS['SQ_SYSTEM']->am->getAsset($GLOBALS['SQ_SYSTEM']->currentUserId());

                $ms = $GLOBALS['SQ_SYSTEM']->getMessagingService();
                $msg = $ms->newMessage();
                $msg_reps     = Array(
                                    'workflow_user' => $user->name,
                                    'type_code'     => $GLOBALS['SQ_SYSTEM']->am->getTypeInfo($this->owner->type(), 'name'),
                                    'asset_name'    => $this->owner->name,
                                    'assetid'       => $this->owner->id,
                                    'status'        => get_status_description($new_status),
                                    'workflow_url'  => current_url().$this->owner->getBackendHref('workflow', FALSE),
                                );
                $msg->replacements = $msg_reps;
                $msg->type = 'asset.workflow.review.cancel';
                $asset_edt_fns = $this->owner->getEditFns();
                if (isset($asset_edt_fns->static_screens['preview'])) {
                    $msg->replacements['preview_url'] = current_url().$this->owner->getBackendHref('preview', FALSE);
                } else {
                    $msg->replacements['preview_url'] = current_url().$this->owner->getBackendHref('details', FALSE);
                }

                if (!$wfm->cancelWorkflow($this->owner->id, $msg)) {
                    trigger_localised_error('SYS0260', E_USER_WARNING);
                    return false;
                }
            }

            // we are safe editing
            if (!$this->owner->saveSystemVersion()) {
                trigger_localised_error('SYS0208', E_USER_WARNING);
                return false;
            }

            require_once SQ_INCLUDE_PATH.'/general_occasional.inc';

            // send an internal message
            $ms = $GLOBALS['SQ_SYSTEM']->getMessagingService();
            $user = $GLOBALS['SQ_SYSTEM']->am->getAsset($current_userid);

            if (!$wfm->silentWorkflowParty($this->owner->id)) {
                $log = $ms->newMessage();
                $msg_reps = Array(
                                'workflow_user' => $user->name,
                                'type_code'     => $GLOBALS['SQ_SYSTEM']->am->getTypeInfo($this->owner->type(), 'name'),
                                'asset_name'    => $this->owner->name,
                                'status'        => get_status_description($new_status),
                                'workflow_url'  => current_url().$this->owner->getBackendHref('workflow', FALSE),
                            );
                $log->replacements = $msg_reps;
                $asset_edt_fns = $this->owner->getEditFns();
                if (isset($asset_edt_fns->static_screens['preview'])) {
                    $log->replacements['preview_url'] = current_url().$this->owner->getBackendHref('preview', FALSE);
                } else {
                    $log->replacements['preview_url'] = current_url().$this->owner->getBackendHref('details', FALSE);
                }

                $log->type = 'asset.workflow.log.review.cancel';
                $log->parameters['assetid'] = $this->owner->id;
                $log->parameters['version'] = substr($this->owner->version, 0, strrpos($this->owner->version, '.'));
                $log->send();
            }

        } else {

            $running_schemas = $wfm->getSchemas($this->owner->id, true, true);
            if (!empty($running_schemas)) {

                // if we are trying to approve this asset, we might not actually be a person
                // in the workflow process - sounds weird (I know) but this could be a plain old
                // admin that is trying to approve because metadata is now complete.
                // the result is that this workflow process may already be complete
                $mm = $GLOBALS['SQ_SYSTEM']->getMetadataManager();
                $m_complete = !$mm->allowsMetadata($this->owner->id) || $mm->requiredFieldsComplete($this->owner->id) || $GLOBALS['SQ_SYSTEM']->am->isDependant($this->owner->id);

                if ($wfm->isWorkflowComplete($this->owner->id) && $m_complete && ($new_status & SQ_STATUS_LIVE)) {
                    if (!$wfm->completeWorkflow($this->owner->id)) {
                        trigger_localised_error('SYS0261', E_USER_WARNING);
                        return false;
                    }
                } else {
                    // we are doing a workflow and someone has just approved the asset, so record this
                    if (!$wfm->recordPublish($this->owner->id, $current_userid)) {
                        trigger_localised_error('SYS0077', E_USER_WARNING, $current_userid, $this->owner->name);
                        return false;
                    }

                    // if the workflow process is now complete, we can go ahead and clear out the schemas
                    // as long as all our metadata is also complete
                    if ($wfm->isWorkflowComplete($this->owner->id) && $m_complete && ($new_status & SQ_STATUS_LIVE)) {
                        if (!$wfm->completeWorkflow($this->owner->id)) {
                            trigger_localised_error('SYS0261', E_USER_WARNING);
                            return false;
                        }
                    }
                }

                if ($new_status == SQ_STATUS_LIVE) {
                    // notify people that the asset has gone live
                    $wfm = $GLOBALS['SQ_SYSTEM']->getWorkflowManager();
                    if (!$wfm->notifyOnLive($this->owner->id, $this->status_tag)) {
                        return false;
                    }

                    // update the last published date
                    if (!$this->owner->setDate('published', time())) {
                        return false;
                    }

                    // log an internal message
                    $ms = $GLOBALS['SQ_SYSTEM']->getMessagingService();
                    $user = $GLOBALS['SQ_SYSTEM']->am->getAsset($current_userid);

                    if (!$wfm->silentWorkflowParty($this->owner->id)) {
                        $log = $ms->newMessage();
                        $msg_reps = Array(
                                        'user_name'     => $user->name,
                                        'workflow_user' => $user->name,
                                        'type_code'     => $GLOBALS['SQ_SYSTEM']->am->getTypeInfo($this->owner->type(), 'name'),
                                        'asset_name'    => $this->owner->name,
                                        'status'        => get_status_description($new_status),
                                        'workflow_url'  => current_url().$this->owner->getBackendHref('workflow', FALSE),
                                    );
                        $log->replacements = $msg_reps;
                        //$log->to = Array(0);
                        $log->type = 'asset.workflow.log.review.complete';
                        $asset_edt_fns = $this->owner->getEditFns();
                        if (isset($asset_edt_fns->static_screens['preview'])) {
                            $log->replacements['preview_url'] = current_url().$this->owner->getBackendHref('preview', FALSE);
                        } else {
                            $log->replacements['preview_url'] = current_url().$this->owner->getBackendHref('details', FALSE);
                        }

                        $log->parameters['assetid'] = $this->owner->id;
                        $log->parameters['version'] = substr($this->owner->version, 0, strrpos($this->owner->version, '.'));
                        $ms->enqueueMessage($log);
                    }
                }

            }//end if

        }//end else

        return true;

    }//end processStatusChange()


}//end class

?>