function Streams_after_Q_objects()
{
$user = Users::loggedInUser();
if (!$user) {
return;
}
$invite = Streams::$followedInvite;
if (!$invite) {
return;
}
$displayName = $user->displayName();
if ($displayName) {
return;
}
$stream = new Streams_Stream();
$stream->publisherId = $invite->publisherId;
$stream->name = $invite->streamName;
if (!$stream->retrieve()) {
throw new Q_Exception_MissingRow(array('table' => 'stream', 'criteria' => 'with that name'), 'streamName');
}
// Prepare the complete invite dialog
$invitingUser = Users_User::fetch($invite->invitingUserId);
list($relations, $related) = Streams::related($user->id, $stream->publisherId, $stream->name, false);
$params = array('displayName' => null, 'action' => 'Streams/basic', 'icon' => $user->iconUrl(), 'token' => $invite->token, 'user' => array('icon' => $invitingUser->iconUrl(), 'displayName' => $invitingUser->displayName(array('fullAccess' => true))), 'stream' => $stream->exportArray(), 'relations' => Db::exportArray($relations), 'related' => Db::exportArray($related));
$config = Streams_Stream::getConfigField($stream->type, 'invite', array());
$defaults = Q::ifset($config, 'dialog', array());
$tree = new Q_Tree($defaults);
if ($tree->merge($params)) {
$dialogData = $tree->getAll();
if ($dialogData) {
Q_Response::setScriptData('Q.plugins.Streams.invite.dialog', $dialogData);
Q_Response::addTemplate('Streams/invite/complete');
}
}
}
/**
* Provide player content to view the members of category listing
* Uses Streams/$type/category.php view (Streams/$streamType/category/get.php can be used for viewing the category
* stream itself if type of category is $streamType/category)
* and Streams::related to retrieve streams data
*
**/
function Streams_category_response_player()
{
$user = Users::loggedInUser();
$userId = $user ? $user->id : 0;
// These are PK of the category!
$publisherId = Streams::requestedPublisherId(true);
$name = Streams::requestedName(true);
// need to know publisher and type of the streams to list
$streamType = Streams::requestedType();
if ($streamType) {
$prefix = "{$streamType}/";
}
$stream_publisherId = Q::expect('Streams', $streamType, 'publisher');
if (substr($name, -1) === '/') {
throw new Q_Exception("Player cannot show listing for multiple categories", compact('publisherId', 'name'));
}
/*
* Get shall return only streams which user is authorized to see.
*/
$categories = Streams::fetch($userId, $publisherId, $name);
if (empty($categories)) {
throw new Q_Exception_MissingRow(array('table' => 'stream', 'criteria' => compact('publisherId', 'name')));
}
$category = reset($categories);
// Are you authorized to see category content?
if (!$category->testReadLevel('content')) {
throw new Users_Exception_NotAuthorized();
}
// get all the streams which are members of this category
// as Streams::get verifies access rights, it's safe to show all streams' content
list($relations, $streams) = Streams::related($userId, $publisherId, $name, true, array('prefix' => $prefix, 'skipAccess' => true));
Q::view("Stream/{$type}/category.php", compact('relations', 'streams', 'userId'));
}
/**
* This tool generates a category selector.
*
* @param array $options
* An associative array of parameters, containing:
* "publisherId" => Optional. publisherId of the stream to present. If "stream" parameter is empty
* defaults to Streams::requestedPublisherId()
* "name" => Optional. the name of the stream to present. If "stream" parameter is empty
* defaults to Streams::requestedName()
* "stream" => Optional. Object. The stream objects to show categories.
*/
function Streams_category_tool($options)
{
extract($options);
$user = Users::loggedInUser(true);
$userId = $user->id;
// PK of stream to manage categories
$publisherId = Streams::requestedPublisherId(true);
$name = Streams::requestedName(true);
$stream = Streams::get($userId, $publisherId, $name, null, true);
if (!$stream) {
throw new Q_Exception_MissingRow(array('table' => 'stream', 'criteria' => "{publisherId: {$publisherId}, name: {$name}}"));
}
// activate tool frontend
$default = array('publisherId' => $stream->publisherId, 'name' => $stream->name);
$options = array_merge($default, $options);
Q_Response::setToolOptions($options);
// get the list of categories
list($relations, $categories) = Streams::related($userId, $publisherId, $name, true);
return Q::view("Streams/tool/category.php", compact('relations', 'categories', 'stream'));
}
function Streams_related_response()
{
if (!Q_Request::slotName('relations') and !Q_Request::slotName('streams')) {
return;
}
$user = Users::loggedInUser();
$asUserId = $user ? $user->id : '';
$publisherId = Streams::requestedPublisherId(true);
$streamName = Streams::requestedName(true, 'original');
$isCategory = !empty($_REQUEST['isCategory']);
$slotNames = Q_Request::slotNames();
$streams_requested = in_array('relatedStreams', $slotNames);
$options = array('relationsOnly' => !$streams_requested, 'orderBy' => !empty($_REQUEST['ascending']));
if (isset($_REQUEST['limit'])) {
$options['limit'] = $_REQUEST['limit'];
}
if (isset($_REQUEST['offset'])) {
$options['offset'] = $_REQUEST['offset'];
}
if (isset($_REQUEST['min'])) {
$options['min'] = $_REQUEST['min'];
}
if (isset($_REQUEST['max'])) {
$options['max'] = $_REQUEST['max'];
}
if (isset($_REQUEST['type'])) {
$options['type'] = $_REQUEST['type'];
}
if (isset($_REQUEST['prefix'])) {
$options['prefix'] = $_REQUEST['prefix'];
}
$result = Streams::related($asUserId, $publisherId, $streamName, $isCategory, $options);
if ($streams_requested) {
$rel = Db::exportArray($result[0], array('numeric' => true));
} else {
$rel = Db::exportArray($result, array('numeric' => true));
}
if (!empty($_REQUEST['omitRedundantInfo'])) {
if ($isCategory) {
foreach ($rel as &$r) {
unset($r['toPublisherId']);
unset($r['toStreamName']);
}
} else {
foreach ($rel as &$r) {
unset($r['fromPublisherId']);
unset($r['fromStreamName']);
}
}
}
Q_Response::setSlot('relations', $rel);
if (!$streams_requested) {
return;
}
$streams = $result[1];
$arr = Db::exportArray($streams, array('numeric' => true));
foreach ($arr as $k => $stream) {
if (!$stream) {
continue;
}
$s = $streams[$stream['name']];
$arr[$k]['access'] = array('readLevel' => $s->get('readLevel', $s->readLevel), 'writeLevel' => $s->get('writeLevel', $s->writeLevel), 'adminLevel' => $s->get('adminLevel', $s->adminLevel));
}
Q_Response::setSlot('relatedStreams', $arr);
$stream = $result[2];
if (is_array($stream)) {
Q_Response::setSlot('streams', Db::exportArray($stream));
return;
} else {
if (is_object($stream)) {
Q_Response::setSlot('stream', $stream->exportArray());
} else {
Q_Response::setSlot('stream', false);
}
}
if (!empty($_REQUEST['messages'])) {
$max = -1;
$limit = $_REQUEST['messages'];
$messages = false;
$type = isset($_REQUEST['messageType']) ? $_REQUEST['messageType'] : null;
if ($stream->testReadLevel('messages')) {
$messages = Db::exportArray($stream->getMessages(compact('type', 'max', 'limit')));
}
Q_Response::setSlot('messages', $messages);
}
if (!empty($_REQUEST['participants'])) {
$limit = $_REQUEST['participants'];
$offset = -1;
$participants = false;
if ($stream->testReadLevel('participants')) {
$participants = Db::exportArray($stream->getParticipants(compact('limit', 'offset')));
}
Q_Response::setSlot('participants', $participants);
}
}
function Shipping_history_response_content($params)
{
// Do controller stuff here. Prepare variables
// get "Shipping/shipments" stream
$env = Shipping::getVars();
Q_Response::addStylesheet('css/ShipmentHistory.css');
Q_Response::addStylesheet('css/jquery.dropdown.css');
Q_Response::addScript('js/jquery.dropdown.js');
// run only once
Q_Response::addScript('js/scheduled.js', "");
Q_Response::addScript('js/date.js', "");
// very first defaultState
$defaultState = "pickup";
$shippingStates = array();
// get states from config
$tmp = Q_Config::expect('Shipping', 'states');
foreach ($tmp as $shippingState) {
// set default state
if (isset($shippingState["default"]) && $shippingState["default"]) {
$defaultState = $shippingState["type"];
}
$shippingStates[$shippingState["type"]] = $shippingState["title"];
}
// state from REQUEST have high priority, then defaultState from config
$defaultState = isset($_REQUEST["type"]) ? $_REQUEST["type"] : $defaultState;
// get next pickup date
$streamsRes = Streams::related($env->communityId, $env->communityId, $env->shipmentsStreamName, true, array("type" => "pickup"));
if (!count($streamsRes[1])) {
$minDate = false;
} else {
$dateNow = new DateTime("now");
//$minDate = new DateTime((date("Y") + 1).'-'.date("m").'-'.date("d"));
$maxDate = $minDate = false;
foreach ($streamsRes[1] as $stream) {
// skip stream if collectInstructions empty
if (empty($stream->fields["collectInstructions"])) {
continue;
}
$exportDate = json_decode($stream->fields["collectInstructions"]);
// skip stream if $exportDate not an object
if (json_last_error() !== JSON_ERROR_NONE || !is_object($exportDate)) {
continue;
}
// if exportDate or collectTimeFrom or collectTimeTo empty - continue
if (!property_exists($exportDate, "exportDate") || !property_exists($exportDate, "collectTimeFrom") || !property_exists($exportDate, "collectTimeTo")) {
continue;
}
$startDate = DateTime::createFromFormat("Y-m-d G:i", $exportDate->exportDate . ' ' . $exportDate->collectTimeFrom);
if ($startDate > $dateNow) {
if (!$minDate || is_a($minDate, "DateTime") && $startDate < $minDate) {
$minDate = $startDate;
$maxDate = DateTime::createFromFormat("Y-m-d G:i", $exportDate->exportDate . ' ' . $exportDate->collectTimeTo);
}
}
}
if (is_a($minDate, "DateTime") && is_a($maxDate, "DateTime")) {
$minDate = $minDate->format("l, j M Y") . " from " . $minDate->format("ga");
$minDate .= " to " . $maxDate->format("ga");
} else {
$minDate = false;
}
}
// collect carriers
$shippingCarriers = array_keys(Q_Config::expect('Shipping', 'carriers'));
$shippingCarriers = array_combine($shippingCarriers, $shippingCarriers);
array_unshift($shippingCarriers, 'All');
//echo $minDate->format("l, j M Y")." from ".$minDate->format("ga")." to ".$maxDate->format("ga"); exit;
return Q::view('Shipping/content/history.php', compact('env', 'shippingStates', 'defaultState', "minDate", "shippingCarriers"));
}
/**
* Fetch all the streams which are related to, or from, this stream.
* @method related
* @static
* @param {string} $asUserId
* The user who is fetching
* @param {string} $publisherId
* An array of criteria that includes either
* @param {string} $toStreamName
* The name of the category
* @param {mixed} $isCategory
* If false, returns the categories that this stream is related to.
* If true, returns all the streams this related to this category.
* If a string, returns all the streams related to this category with names prefixed by this string.
* @param {array} $options=array()
* 'limit' => number of records to fetch
* 'offset' => offset to start
* 'orderBy' => defaults to false, which means order by descending weight
* 'type' => if specified, this filters the type of the relation
* 'prefix' => if specified, this filters by the prefix of the related streams
* 'where' => you can also specify any extra conditions here
* 'extra' => An array of any extra options to pass to Streams::fetch when fetching streams
* 'relationsOnly' => If true, returns only the relations to/from stream, doesn't fetch the streams.
* Useful if publisher id of relation objects is not the same as provided by publisherId.
* 'streamsOnly' => If true, returns only the streams related to/from stream, doesn't return the relations.
* Useful for shorthand in while( ) statements.
* 'streamFields' => If specified, fetches only the fields listed here for any streams
* 'skipFields' => Optional array of field names. If specified, skips these fields when fetching streams
* @return {array}
* Returns array($relations, $relatedStreams, $this)
*/
function related($asUserId, $isCategory = true, $options = array())
{
return Streams::related($asUserId, $this->publisherId, $this->name, $isCategory, $options);
}
/**
* Closes a stream, which prevents anyone from posting messages to it
* unless they have WRITE_LEVEL >= "close", as well as attempting to remove
* all relations to other streams. A "cron job" can later go and delete
* closed streams. The reason you should avoid deleting streams right away
* is that other subscribers may still want to receive the last messages
* posted to the stream.
* @method close
* @param {string} $asUserId The id of the user who would be closing the stream
* @param {string} $publisherId The id of the user publishing the stream
* @param {string} $streamName The name of the stream
* @param {array} [$options=array()] Can include "skipAccess"
* @static
*/
static function close($asUserId, $publisherId, $streamName, $options = array())
{
$stream = new Streams_Stream();
$stream->publisherId = $publisherId;
$stream->name = $streamName;
if (!$stream->retrieve()) {
throw new Q_Exception_MissingRow(array('table' => 'stream', 'criteria' => "{publisherId: '{$publisherId}', name: '{$streamName}'}"));
}
// Authorization check
if (empty($options['skipAccess'])) {
if ($asUserId !== $publisherId) {
$stream->calculateAccess($asUserId);
if (!$stream->testWriteLevel('close')) {
throw new Users_Exception_NotAuthorized();
}
}
}
// Clean up relations from other streams to this category
list($relations, $related) = Streams::related($asUserId, $stream->publisherId, $stream->name, true);
foreach ($relations as $r) {
try {
Streams::unrelate($asUserId, $r->fromPublisherId, $r->fromStreamName, $r->type, $stream->publisherId, $stream->name);
} catch (Exception $e) {
}
}
// Clean up relations from this stream to categories
list($relations, $related) = Streams::related($asUserId, $stream->publisherId, $stream->name, false);
foreach ($relations as $r) {
try {
Streams::unrelate($asUserId, $r->toPublisherId, $r->toStreamName, $r->type, $stream->publisherId, $stream->name);
} catch (Exception $e) {
}
}
$result = false;
try {
$db = $stream->db();
$stream->closedTime = $closedTime = $db->toDateTime($db->getCurrentTimestamp());
if ($stream->save()) {
$stream->post($asUserId, array('type' => 'Streams/closed', 'content' => '', 'instructions' => compact('closedTime')), true);
$result = true;
}
} catch (Exception $e) {
throw $e;
}
return $result;
}
function Shipping_invoice_response_content($params)
{
$publisherId = Users::communityId();
$streamName = 'Shipping/shipment/' . Q_Request::uri()->shipmentStreamName;
$stream = Streams::fetchOne($publisherId, $publisherId, $streamName);
$relation = Shipping::getShipmentRelation($stream);
if (!$stream->testReadLevel('see')) {
throw new Users_Exception_NotAuthorized();
}
$carrier = json_decode($stream->carrier) ?: new StdClass();
// check if related invoices exists
$invoices = Streams::related($stream->publisherId, $stream->publisherId, $stream->name, true, array("type" => "invoice"));
$invoicesCount = count($invoices[1]);
if ($invoicesCount) {
$invoice = array_shift($invoices[1]);
// for UPS fix PDF invoice to use tracking id in Waybill Number field
if ($carrier->name == "UPS") {
Shipping_Carrier_UPS::fixInvoice(APP_DIR . "/web/" . $invoice->content, $stream);
exit;
}
header("location: " . Q_Request::baseUrl() . '/' . $invoice->content);
exit;
}
//----------------------------------
// check if airwaybill bar code exist
$carrier->AWBBarCode = false;
$barCodes = Streams::related($stream->publisherId, $stream->publisherId, $stream->name, true, array("type" => "AWBBarCode"));
$barCodesCount = count($barCodes[1]);
if ($barCodesCount) {
$barCode = array_shift($barCodes[1]);
$carrier->AWBBarCode = Q_Request::baseUrl() . '/' . $barCode->content;
}
/*
$carrier = json_decode($stream->fields['carrier']);
if($carrier->name == "TNT"){
header ("Content-Type:text/xml");
echo $stream->fields['carrierInvoice'];
exit;
}*/
$addressReceiver = json_decode($stream->receiver) ?: new StdClass();
$addressReceiver->street = implode("<br>", Shipping_Carrier::addAddressLine($addressReceiver));
$addressFrom = json_decode($stream->origin) ?: new StdClass();
$addressFrom->street = implode("<br>", Shipping_Carrier::addAddressLine($addressFrom));
$addressTo = json_decode($stream->destination) ?: new StdClass();
$addressTo->street = implode("<br>", Shipping_Carrier::addAddressLine($addressTo));
$packages = json_decode($stream->packages) ?: new StdClass();
$products = json_decode($stream->products) ?: new StdClass();
$products->packages = Q::ifset($products, 'packages', array());
$products->currency = Q::ifset($products, 'currency', '');
if (!$carrier->name) {
throw new exception("Carrier name empty!");
}
if (!array_key_exists($carrier->name, Q_Config::expect('Shipping', 'carriers'))) {
throw new exception("Unexpected carrier name " . $carrier->name . "!");
}
$carrier->trackingId = Q::ifset($carrier, 'trackingId', '');
//$carrier->shipmentId = Q::ifset($carrier, 'waybillNumber', '');
$invoiceOptions = json_decode($stream->invoiceOptions) ?: new StdClass();
$invoiceOptions->invoiceNumber = Q::ifset($invoiceOptions, 'invoiceNumber', '');
$invoiceOptions->purchaseOrderNo = Q::ifset($invoiceOptions, 'purchaseOrderNo', '');
$invoiceOptions->reasonForExport = Q::ifset($invoiceOptions, 'reasonForExport', '');
$invoiceOptions->termsOfDelivery = Q::ifset($invoiceOptions, 'termsOfDelivery', '');
// normalize termsOfDelivery
if ($invoiceOptions->termsOfDelivery) {
$termsOfDelivery = Q_Config::expect('Shipping', "options", "termsOfDelivery");
if (array_key_exists($invoiceOptions->termsOfDelivery, $termsOfDelivery)) {
$invoiceOptions->termsOfDelivery = $termsOfDelivery[$invoiceOptions->termsOfDelivery]["name"];
}
}
$invoiceOptions->ftrExemptions = Q::ifset($invoiceOptions, 'ftrExemptions', '');
$collectInstructions = json_decode($stream->collectInstructions) ?: new StdClass();
$collectInstructions->exportDate = Q::ifset($collectInstructions, 'exportDate', '');
Q_Response::addStylesheet('css/ShipmentInvoice.css');
Q_Response::addStylesheet('css/ShipmentInvoice' . $carrier->name . '.css');
//Q_Response::addStylesheet('js/jquery-editable/jquery-editable/css/jquery-editable.css');
//Q_Response::addScript('js/jquery-editable/jquery-editable/js/jquery-editable-poshytip.js');
//Q_Response::addScriptLine("$.fn.editable.defaults.mode = 'inline';");
return Q::view('Shipping/content/invoice' . $carrier->name . '.php', compact('addressFrom', 'addressTo', 'addressReceiver', 'packages', 'products', 'carrier', 'invoiceOptions', 'collectInstructions', 'streamName', 'relation'));
}
function Shipping_label_response_content($params)
{
$streamName = Q_Request::uri()->shipmentStreamName;
$publisherId = Users::communityId();
$stream = Streams::fetchOne($publisherId, $publisherId, 'Shipping/shipment/' . $streamName);
if (!$stream->testReadLevel('see')) {
throw new Users_Exception_NotAuthorized();
}
$carrier = json_decode($stream->fields['carrier']) ?: new StdClass();
if (!is_object($carrier)) {
throw new exception("carrier is not an object!");
}
// TNT carrier
if ($carrier->name == "TNT") {
$xml = new XMLReader();
// check if XML valid
if (!$xml->xml($stream->fields['carrierLabel'], NULL, LIBXML_DTDVALID)) {
die("XML not valid");
}
// add back button
$stream->fields['carrierLabel'] = preg_replace("/<CONSIGNMENTBATCH>/", "<CONSIGNMENTBATCH>\n<ISWEBVIEW>" . Q_Request::isWebView() . "</ISWEBVIEW>", $stream->fields['carrierLabel']);
// add FTR Exemptions
$invoice = json_decode($stream->invoiceOptions) ?: new StdClass();
$stream->fields['carrierLabel'] = preg_replace("/<CONSIGNMENTBATCH>/", "<CONSIGNMENTBATCH>\n<FTR>" . $invoice->ftrExemptions . "</FTR>", $stream->fields['carrierLabel']);
header("Content-Type:text/xml");
echo $stream->fields['carrierLabel'];
exit;
} elseif (in_array($carrier->name, array("UPS", "FEDEX"))) {
$labels = Streams::related($stream->publisherId, $stream->publisherId, $stream->name, true, array("type" => "label"));
$orient = Q_Config::expect('Shipping', 'labelsOption', 'orient');
$perPage = (int) Q_Config::expect('Shipping', 'labelsOption', 'perPage');
// angle label rotate 90 or -90
$angle = 1;
// for UPS -90, for other 90
if ($carrier->name == "UPS") {
$angle = -1;
}
// include labels size calculation for all labels
Q_Response::addScript('js/labels.js');
Q_Response::addStylesheet('css/ShipmentLabels.css');
if ($orient == "vertical") {
Q_Response::addStylesheet('css/ShipmentLabelsVertical.css');
}
return Q::view('Shipping/content/imgLabels.php', compact('labels', 'perPage', 'angle'));
} elseif ($carrier->name == "DHL") {
$labels = Streams::related($stream->publisherId, $stream->publisherId, $stream->name, true, array("type" => "label"));
$labelsCount = count($labels[1]);
if ($labelsCount) {
$label = array_shift($labels[1]);
Shipping_Carrier_DHL::fixLabels(APP_DIR . "/web/" . $label->content, $stream);
exit;
//header("location: ".Q_Request::baseUrl().'/'.$label->content);
//exit;
}
}
$title = $stream->fields['title'];
$addressFrom = json_decode($stream->fields['origin']);
$addressTo = json_decode($stream->fields['destination']);
$packages = json_decode($stream->fields['packages']);
//$carrier = json_decode($stream->fields['carrier']);
$invoiceOptions = json_decode($stream->fields['invoiceOptions']);
$addressFrom = ($addressFrom->name ? $addressFrom->name . "<br>" : '') . $addressFrom->street . ($addressFrom->unit ? ' ' . $addressFrom->unit : '') . "<br>" . $addressFrom->city . ' ' . $addressFrom->zipcode . "<br>" . $addressFrom->country;
$addressTo = ($addressTo->name ? $addressTo->name . "<br>" : '') . $addressTo->street . ($addressTo->unit ? ' ' . $addressTo->unit : '') . "<br>" . "<span class='city'>" . $addressTo->city . ' ' . $addressTo->zipcode . "</span><br>" . $addressTo->country;
$exportDate = $invoiceOptions->exportDate;
$class = "Shipping_Carrier_" . strtoupper($carrier->name);
$labels = $class::labels($addressFrom, $addressTo, $packages, $carrier, $exportDate);
echo <<<EOT
\t<!DOCTYPE html>
\t<html>
\t<head>
\t\t<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
\t\t<title>Labels for {$title}</title>
\t</head>
\t<body>
\t{$labels}
\t</body>
</html>
EOT;
exit;
}
/**
* Get (if exist) or create shipment stream with type=describing for current user
* @method shipment
* @static
* @return Object
*/
static function shipment()
{
$env = self::getVars();
// Collect streams for shipments. Relations: "describing", "scheduled", "confirmed", "shipping", "canceled", "returned"
$streamsRes = Streams::related($env->userId, $env->communityId, $env->shipmentsStreamName, true, array("type" => "describing"));
// if stream exists - return one
if ($streamsRes[1]) {
return reset($streamsRes[1]);
}
// if no streams with relation "describing" - create this stream
// get last scheduled shippment stream
$streamsScheduled = self::getRealShipments();
// find most new stream processed (not describing)
$lastScheduled = false;
foreach ($streamsScheduled[0] as $streamScheduled) {
if (!$lastScheduled) {
$lastScheduled = $streamScheduled;
continue;
}
if ($streamScheduled->fields["insertedTime"] > $lastScheduled->fields["insertedTime"]) {
$lastScheduled = $streamScheduled;
}
}
// set Stream object instead of related object
if ($lastScheduled) {
$lastScheduled = $streamsScheduled[1][$lastScheduled->fields["fromStreamName"]];
$lastCarrier = json_decode($lastScheduled->fields["carrier"]);
}
// default carrier if no scheduled shippments
if (!isset($lastCarrier) || !is_object($lastCarrier)) {
$lastCarrier = json_decode("{name: 'TNT'}");
}
return Streams::create($env->communityId, $env->communityId, 'Shipping/shipment', array("readLevel" => Streams::$READ_LEVEL['messages'], "writeLevel" => Streams::$WRITE_LEVEL['edit'], "skipAccess" => true, 'attributes' => '{"carrier":"' . $lastCarrier->name . '"}', 'title' => ''), array('publisherId' => $env->communityId, 'streamName' => $env->shipmentsStreamName, 'type' => 'describing', 'weight' => time()));
}
