asset_status_under_construction.inc

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

class Asset_Status_Under_Construction extends Asset_Status
{


    function Asset_Status_Under_Construction($owner)
    {
        $this->Asset_Status($owner);
        $this->status_tag = SQ_STATUS_UNDER_CONSTRUCTION;

    }//end constructor


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

    }//end getDescription()


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

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

        // any admin can change the status to ARCHIVED
        if ($this->owner->adminAccess('')) {
            $statii[SQ_STATUS_ARCHIVED] = translate('status_change_archive');
        }

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

        if (!empty($running_schemas)) {
            // workflow is currently running, but it should not be
            // because UNDER_CONSTRUCTION does not require workflow
            pre_echo('FIXME: SOMETHING HAS GONE WRONG HERE');
        } else {
            // workflow is not currently running for this asset
            $schemas = $wfm->getSchemas($this->owner->id, true);
            if (empty($schemas)) {
                // no workflow defined, so any admin can make this live
                if ($this->owner->adminAccess('')) {
                    if (!$GLOBALS['SQ_SYSTEM']->am->isDependant($this->owner->id)) {
                        if (!isset($this->_tmp['metadata_complete'])) {
                            $mm = $GLOBALS['SQ_SYSTEM']->getMetadataManager();
                            $this->_tmp['metadata_complete'] = $mm->requiredFieldsComplete($this->owner->id);
                        }
                    } else {
                            $this->_tmp['metadata_complete'] = TRUE;
                    }
                    if ($this->_tmp['metadata_complete']) {
                        $statii[SQ_STATUS_LIVE] = translate('status_change_approve_and_make_live');
                    }
                }
            } else {
                // so we have workflows, but none of them are running so lets see what will happen
                // if this user approves to determine if they can live edit
                if ($this->owner->adminAccess('')) {
                    // If we are an admin, we should test all the streams
                    // to see if some need workflow and others don't
                    $needs_workflow = FALSE;
                    $wf_complete    = FALSE;

                    foreach ($schemas as $schemaid) {
                        $streams = $wfm->getStreams($schemaid);

                        foreach ($streams as $streamid => $stream_name) {
                            $publish_result = $wfm->testPublish($this->owner->id, $GLOBALS['SQ_SYSTEM']->currentUserId(), $stream_name);
                            if ($publish_result === TRUE) {
                                $wf_complete = TRUE;
                            } else {
                                $needs_workflow = TRUE;
                            }
                        }
                    }
                } else {
                    // If we are a normal user, we can only use the default
                    // stream, so only test that instead
                    $wf_complete = $wfm->testPublish($this->owner->id, $GLOBALS['SQ_SYSTEM']->currentUserId(), '');
                    $needs_workflow = !$wf_complete;
                }

                // we also need to check what if all the required metadata fields are completed
                $mm = $GLOBALS['SQ_SYSTEM']->getMetadataManager();
                if ($mm->allowsMetadata($this->owner->id)) {
                    
                    $m_complete = $mm->requiredFieldsComplete($this->owner->id);
                    $is_dependant = $GLOBALS['SQ_SYSTEM']->am->isDependant($this->owner->id);

                    // In the case of multiple streams, we may need to provide
                    // BOTH 'approve' and 'apply for approval' if some streams
                    // can be approved bypassing workflow, and some can't.
                    if ($wf_complete === TRUE && (($m_complete === TRUE && !$is_dependant) || $is_dependant)) {
                        $statii[SQ_STATUS_APPROVED] = translate('status_change_approve');
                    }
                    if (($needs_workflow === TRUE) || ($m_complete === FALSE && !$is_dependant)) {
                        $statii[SQ_STATUS_PENDING_APPROVAL] = translate('status_change_apply_for_approval');
                    }
                } else {
                    // this asset needs to allow status "apply for approval" and "approve change" (if workflow is complete),
                    // because asset does not allows metadata
                    if ($wf_complete) {
                        $statii[SQ_STATUS_APPROVED] = translate('status_change_approve');
                    }
                    $statii[SQ_STATUS_PENDING_APPROVAL] = translate('status_change_apply_for_approval');
                }
            }

        }//end if workflow running

        return $statii;

    }//end getAvailableStatii()


    function getStatusChangeMessage()
    {
        if (!isset($this->_tmp['metadata_complete'])) {
            $mm = $GLOBALS['SQ_SYSTEM']->getMetadataManager();
            $this->_tmp['metadata_complete'] = $mm->requiredFieldsComplete($this->owner->id);
        }
        if (!$this->_tmp['metadata_complete']) {
            $replace_string_vars    = Array (
                                        'asset_ei_screen'   => 'metadata',
                                        'am_section'        => 'edit_asset',
                                        'assetid'           => $this->owner->id,
                                      );
            $metadata_screen_url = htmlspecialchars(replace_query_string_vars($replace_string_vars));
            return translate('cannot_make_live_metadata_incomplete', '<a href="'.$metadata_screen_url.'">'.strtolower(translate('metadata')).'</a>');

        }
        return '';

    }//end getStatusChangeMessage()


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

        // so we know we can set the status but we need to
        // do some workflow stuff if we are changing to PENDING APPROVAL
        switch ($new_status) {
            case SQ_STATUS_PENDING_APPROVAL:
                $wfm = $GLOBALS['SQ_SYSTEM']->getWorkflowManager();

                // we are going to make this asset live by starting the workflow process
                $current_userid = $GLOBALS['SQ_SYSTEM']->currentUserId();

                if (!$wfm->startWorkflow($this->owner->id)) {
                    trigger_localised_error('SYS0262', E_USER_WARNING, $this->owner->name);
                    return false;
                }

                // log a message to let people know that workflow has started
                $ms   = $GLOBALS['SQ_SYSTEM']->getMessagingService();
                $user = $GLOBALS['SQ_SYSTEM']->am->getAsset($current_userid);
                $msg_reps   = Array();

                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'        => $this->getDescription(),
                                        '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.started';
                    $log->parameters['assetid'] = $this->owner->id;
                    $log->parameters['version'] = substr($this->owner->version, 0, strrpos($this->owner->version, '.'));
                    $ms->enqueueMessage($log);

                    $running_schemas = $wfm->getSchemas($this->owner->id, TRUE, TRUE);
                    foreach ($running_schemas as $schemaid) {
                        $publishers = $wfm->whoCanPublish($this->owner->id, $schemaid);
                        if (count($publishers) > 0) {
                            $msg = $ms->newMessage();
                            $msg->type = 'asset.workflow.announce.started';

                            // see if we have the 'from' field set
                            $schema = $GLOBALS['SQ_SYSTEM']->am->getAsset($schemaid);
                            if ($schema->attr('schema_reply_to_email_address') != '') {
                                $msg->parameters['reply_to'] = $schema->attr('schema_reply_to_email_address');
                            } else {
                                $msg->parameters['reply_to'] = $GLOBALS['SQ_SYSTEM']->currentUserId();
                            }
                            if ($schema->attr('schema_from_email_address') != '') {
                                $msg->from = $schema->attr('schema_from_email_address');
                            }

                            $msg->to = array_merge($msg->to, $publishers);
                            $msg->replacements = $msg_reps;
                            $msg->parameters['assetid'] = $this->owner->id;
                            $ms->enqueueMessage($msg);
                        }
                    }
                }
            break;

            case 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;
                }
            break;

            case SQ_STATUS_APPROVED :

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

                // we are going approve this asset instead of initiating the workflow
                $current_userid = $GLOBALS['SQ_SYSTEM']->currentUserId();
                $wfm->setCurrentUserAsLastStarted($current_userid, $this->owner->id);

            break;
        }

        return true;

    }//end processStatusChange()


}//end class

?>