PHP Q::eventStack方法代码示例

 /**
  * Does necessary preparations for saving a stream in the database.
  * @method beforeSave
  * @param {array} $modifiedFields
  *	The array of fields
  * @return {array}
  * @throws {Exception}
  *	If mandatory field is not set
  */
 function beforeSave($modifiedFields)
 {
     if (empty($this->attributes)) {
         $this->attributes = '{}';
     }
     if (!$this->retrieved) {
         // Generate a unique name for the stream
         if (!isset($modifiedFields['name'])) {
             $this->name = $modifiedFields['name'] = Streams::db()->uniqueId(Streams_Stream::table(), 'name', array('publisherId' => $this->publisherId), array('prefix' => $this->type . '/Q'));
         }
         // we don't want user to update private fields but will set initial values to them
         $privateFieldNames = self::getConfigField($this->type, 'private', array());
         // magic fields are handled by parent method
         $magicFieldNames = array('insertedTime', 'updatedTime');
         $privateFieldNames = array_diff($privateFieldNames, $magicFieldNames);
         $streamTemplate = $this->getStreamTemplate('Streams_Stream');
         $fieldNames = Streams_Stream::fieldNames();
         if ($streamTemplate) {
             // if template exists copy all non-PK and non-magic fields from template
             foreach (array_diff($fieldNames, $this->getPrimaryKey(), $magicFieldNames) as $field) {
                 if (in_array($field, $privateFieldNames) || !array_key_exists($field, $modifiedFields)) {
                     $this->{$field} = $modifiedFields[$field] = $streamTemplate->{$field};
                 }
             }
         } else {
             // otherwise (no template) set all private fields to defaults
             foreach ($privateFieldNames as $field) {
                 $defaults = self::getConfigField($this->type, 'defaults', Streams_Stream::$DEFAULTS);
                 $this->{$field} = $modifiedFields[$field] = Q::ifset($defaults, $field, null);
             }
         }
         // Assign default values to fields that haven't been set yet
         foreach (array_diff($fieldNames, $magicFieldNames) as $field) {
             if (!array_key_exists($field, $this->fields) and !array_key_exists($field, $modifiedFields)) {
                 $defaults = self::getConfigField($this->type, 'defaults', Streams_Stream::$DEFAULTS);
                 $this->{$field} = $modifiedFields[$field] = Q::ifset($defaults, $field, null);
             }
         }
         // Get all access templates and save corresponding access
         $type = true;
         $accessTemplates = $this->getStreamTemplate('Streams_Access', $type);
         for ($i = 1; $i <= 3; ++$i) {
             foreach ($accessTemplates[$i] as $template) {
                 $access = new Streams_Access();
                 $access->copyFrom($template->toArray());
                 $access->publisherId = $this->publisherId;
                 $access->streamName = $this->name;
                 if (!$access->save(true)) {
                     return false;
                     // JUNK: this leaves junk in the database, but preserves consistency
                 }
             }
         }
     }
     /**
      * @event Streams/Stream/save/$streamType {before}
      * @param {Streams_Stream} stream
      * @return {false} To cancel further processing
      */
     $params = array('stream' => $this, 'modifiedFields' => $modifiedFields);
     if (false === Q::event("Streams/Stream/save/{$this->type}", $params, 'before')) {
         return false;
     }
     foreach ($this->fields as $name => $value) {
         if (!empty($this->fieldsModified[$name])) {
             $modifiedFields[$name] = $value;
         }
     }
     $this->beforeSaveExtended($modifiedFields);
     $result = parent::beforeSave($modifiedFields);
     // Assume that the stream's name is not being changed
     $fields = array('Streams/user/firstName' => false, 'Streams/user/lastName' => false, 'Streams/user/username' => 'username', 'Streams/user/icon' => 'icon');
     if (!isset($fields[$this->name])) {
         return $result;
     }
     $field = $this->name === 'Streams/user/icon' ? 'icon' : 'content';
     $wasModified = !empty($this->fieldsModified[$field]) or !empty($this->fieldsModified['readLevel']);
     if (!$wasModified) {
         return $result;
     }
     if ($publicField = $fields[$this->name] and !Q::eventStack('Db/Row/Users_User/saveExecute')) {
         Streams::$beingSaved[$publicField] = $this;
         try {
             $user = Users_User::fetch($this->publisherId, true);
             $user->{$publicField} = $modifiedFields[$field];
             $user->save();
         } catch (Exception $e) {
             Streams::$beingSaved[$publicField] = array();
             throw $e;
         }
         Streams::$beingSaved[$publicField] = array();
//.........这里部分代码省略.........

/**
 * The default implementation.
 */
function Q_errors($params)
{
    extract($params);
    /**
     * @var Exception $exception
     * @var boolean $startedResponse
     */
    if (!empty($exception)) {
        Q_Response::addError($exception);
    }
    $errors = Q_Response::getErrors();
    $errors_array = Q_Exception::toArray($errors);
    // Simply return the errors, if this was an AJAX request
    if ($is_ajax = Q_Request::isAjax()) {
        try {
            $errors_json = @Q::json_encode($errors_array);
        } catch (Exception $e) {
            $errors_array = array_slice($errors_array, 0, 1);
            unset($errors_array[0]['trace']);
            $errors_json = @Q::json_encode($errors_array);
        }
        $json = "{\"errors\": {$errors_json}}";
        $callback = Q_Request::callback();
        switch (strtolower($is_ajax)) {
            case 'iframe':
                if (!Q_Response::$batch) {
                    header("Content-type: text/html");
                }
                echo <<<EOT
<!doctype html><html lang=en>
<head><meta charset=utf-8><title>Q Result</title></head>
<body>
<script type="text/javascript">
window.result = function () { return {$json} };
</script>
</body>
</html>
EOT;
                break;
            case 'json':
            default:
                header("Content-type: " . ($callback ? "application/javascript" : "application/json"));
                echo $callback ? "{$callback}({$json})" : $json;
        }
        return;
    }
    // Forward internally, if it was requested
    if ($onErrors = Q_Request::special('onErrors', null)) {
        $uri1 = Q_Dispatcher::uri();
        $uri2 = Q_Uri::from($onErrors);
        $url2 = $uri2->toUrl();
        if (!isset($uri2)) {
            throw new Q_Exception_WrongValue(array('field' => 'onErrors', 'range' => 'an internal URI reachable from a URL'));
        }
        if ($uri1->toUrl() !== $url2) {
            Q_Dispatcher::forward($uri2);
            return;
            // we don't really need this, but it's here anyway
        }
    }
    $params2 = compact('errors', 'exception', 'errors_array', 'exception_array');
    if (Q::eventStack('Q/response')) {
        // Errors happened while rendering response. Just render errors view.
        return Q::view('Q/errors.php', $params2);
    }
    if (!$startedResponse) {
        try {
            // Try rendering the response, expecting it to
            // display the errors along with the rest.
            $ob = new Q_OutputBuffer();
            Q::event('Q/response', $params2);
            $ob->endFlush();
            return;
        } catch (Exception $e) {
            if (get_class($e) === 'Q_Exception_DispatcherForward') {
                throw $e;
                // if forwarding was requested, do it
                // for all other errors, continue trying other things
            }
            $output = $ob->getClean();
        }
    }
    if ($errors) {
        // Try rendering the app's errors response, if any.
        $app = Q::app();
        if (Q::canHandle("{$app}/errors/response/content")) {
            Q_Dispatcher::forward("{$app}/errors");
        } else {
            echo Q::view("Q/errors.php", compact('errors'));
        }
    }
    if (!empty($e)) {
        return Q::event('Q/exception', array('exception' => $e));
    }
}