PHP entryFilter::setPartnerSearchScope方法代码示例

 /**
  * @action getFeed
  * @disableTags TAG_WIDGET_SESSION,TAG_ENTITLEMENT_ENTRY,TAG_ENTITLEMENT_CATEGORY
  * @param int $distributionProfileId
  * @param string $hash
  * @return file
  */
 public function getFeedAction($distributionProfileId, $hash)
 {
     if (!$this->getPartnerId() || !$this->getPartner()) {
         throw new KalturaAPIException(KalturaErrors::INVALID_PARTNER_ID, $this->getPartnerId());
     }
     $profile = DistributionProfilePeer::retrieveByPK($distributionProfileId);
     if (!$profile || !$profile instanceof UverseDistributionProfile) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_NOT_FOUND, $distributionProfileId);
     }
     if ($profile->getStatus() != KalturaDistributionProfileStatus::ENABLED) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_DISABLED, $distributionProfileId);
     }
     if ($profile->getUniqueHashForFeedUrl() != $hash) {
         throw new KalturaAPIException(UverseDistributionErrors::INVALID_FEED_URL);
     }
     // "Creates advanced filter on distribution profile
     $distributionAdvancedSearch = new ContentDistributionSearchFilter();
     $distributionAdvancedSearch->setDistributionProfileId($profile->getId());
     $distributionAdvancedSearch->setDistributionSunStatus(EntryDistributionSunStatus::AFTER_SUNRISE);
     $distributionAdvancedSearch->setEntryDistributionStatus(EntryDistributionStatus::READY);
     $distributionAdvancedSearch->setHasEntryDistributionValidationErrors(false);
     //Creates entry filter with advanced filter
     $entryFilter = new entryFilter();
     $entryFilter->setStatusEquel(entryStatus::READY);
     $entryFilter->setModerationStatusNot(entry::ENTRY_MODERATION_STATUS_REJECTED);
     $entryFilter->setPartnerSearchScope($this->getPartnerId());
     $entryFilter->setAdvancedSearch($distributionAdvancedSearch);
     $baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $baseCriteria->add(entryPeer::DISPLAY_IN_SEARCH, mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM, Criteria::NOT_EQUAL);
     $entryFilter->attachToCriteria($baseCriteria);
     $entries = entryPeer::doSelect($baseCriteria);
     $feed = new UverseFeed('uverse_template.xml');
     $feed->setDistributionProfile($profile);
     $feed->setChannelFields();
     $lastBuildDate = $profile->getUpdatedAt(null);
     foreach ($entries as $entry) {
         /* @var $entry entry */
         $entryDistribution = EntryDistributionPeer::retrieveByEntryAndProfileId($entry->getId(), $profile->getId());
         if (!$entryDistribution) {
             KalturaLog::err('Entry distribution was not found for entry [' . $entry->getId() . '] and profile [' . $profile->getId() . ']');
             continue;
         }
         $fields = $profile->getAllFieldValues($entryDistribution);
         $flavorAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getFlavorAssetIds()));
         $flavorAsset = reset($flavorAssets);
         $flavorAssetRemoteUrl = $entryDistribution->getFromCustomData(UverseEntryDistributionCustomDataField::REMOTE_ASSET_URL);
         $thumbAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getThumbAssetIds()));
         $feed->addItem($fields, $flavorAsset, $flavorAssetRemoteUrl, $thumbAssets);
         // we want to find the newest update time between all entries
         if ($entry->getUpdatedAt(null) > $lastBuildDate) {
             $lastBuildDate = $entry->getUpdatedAt(null);
         }
     }
     $feed->setChannelLastBuildDate($lastBuildDate);
     header('Content-Type: text/xml');
     echo $feed->getXml();
     die;
 }

 /**
  * @action getFeed
  * @disableTags TAG_WIDGET_SESSION,TAG_ENTITLEMENT_ENTRY,TAG_ENTITLEMENT_CATEGORY
  * @param int $distributionProfileId
  * @param string $hash
  * @return file
  */
 public function getFeedAction($distributionProfileId, $hash)
 {
     if (!$this->getPartnerId() || !$this->getPartner()) {
         throw new KalturaAPIException(KalturaErrors::INVALID_PARTNER_ID, $this->getPartnerId());
     }
     $profile = DistributionProfilePeer::retrieveByPK($distributionProfileId);
     if (!$profile || !$profile instanceof SynacorHboDistributionProfile) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_NOT_FOUND, $distributionProfileId);
     }
     if ($profile->getStatus() != KalturaDistributionProfileStatus::ENABLED) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_DISABLED, $distributionProfileId);
     }
     if ($profile->getUniqueHashForFeedUrl() != $hash) {
         throw new KalturaAPIException(SynacorHboDistributionErrors::INVALID_FEED_URL);
     }
     // "Creates advanced filter on distribution profile
     $distributionAdvancedSearch = new ContentDistributionSearchFilter();
     $distributionAdvancedSearch->setDistributionProfileId($profile->getId());
     $distributionAdvancedSearch->setDistributionSunStatus(EntryDistributionSunStatus::AFTER_SUNRISE);
     $distributionAdvancedSearch->setEntryDistributionStatus(EntryDistributionStatus::READY);
     $distributionAdvancedSearch->setEntryDistributionFlag(EntryDistributionDirtyStatus::NONE);
     $distributionAdvancedSearch->setHasEntryDistributionValidationErrors(false);
     //Creates entry filter with advanced filter
     $entryFilter = new entryFilter();
     $entryFilter->setStatusEquel(entryStatus::READY);
     $entryFilter->setModerationStatusNot(entry::ENTRY_MODERATION_STATUS_REJECTED);
     $entryFilter->setPartnerSearchScope($this->getPartnerId());
     $entryFilter->setAdvancedSearch($distributionAdvancedSearch);
     $baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $baseCriteria->add(entryPeer::DISPLAY_IN_SEARCH, mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM, Criteria::NOT_EQUAL);
     $entryFilter->attachToCriteria($baseCriteria);
     $entries = entryPeer::doSelect($baseCriteria);
     $feed = new SynacorHboFeed('synacor_hbo_feed_template.xml');
     $feed->setDistributionProfile($profile);
     $counter = 0;
     foreach ($entries as $entry) {
         /* @var $entry entry */
         $entryDistribution = EntryDistributionPeer::retrieveByEntryAndProfileId($entry->getId(), $profile->getId());
         if (!$entryDistribution) {
             KalturaLog::err('Entry distribution was not found for entry [' . $entry->getId() . '] and profile [' . $profile->getId() . ']');
             continue;
         }
         $fields = $profile->getAllFieldValues($entryDistribution);
         $flavorAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getFlavorAssetIds()));
         $thumbAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getThumbAssetIds()));
         $additionalAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getAssetIds()));
         $feed->addItem($fields, $entry, $flavorAssets, $thumbAssets, $additionalAssets);
         $counter++;
         //to avoid the cache exceeding the memory size
         if ($counter >= 100) {
             kMemoryManager::clearMemory();
             $counter = 0;
         }
     }
     header('Content-Type: text/xml');
     echo $feed->getXml();
     die;
 }

 protected function getEntryFilter($extraData)
 {
     $entry_filter = new entryFilter();
     // This is the old way to search within a partner - allow both
     $entry_filter->setByName("_eq_partner_id", $extraData);
     // this is the better way -
     $entry_filter->setPartnerSearchScope($extraData);
     return $entry_filter;
 }

 protected function getEntryFilter($context, $keepScheduling = true)
 {
     // "Creates advanced filter on distribution profile
     $distributionAdvancedSearch = new ContentDistributionSearchFilter();
     $distributionAdvancedSearch->setDistributionProfileId($this->profile->getId());
     $distributionAdvancedSearch->setDistributionSunStatus(EntryDistributionSunStatus::AFTER_SUNRISE);
     $distributionAdvancedSearch->setEntryDistributionStatus(EntryDistributionStatus::READY);
     $distributionAdvancedSearch->setHasEntryDistributionValidationErrors(false);
     //Creates entry filter with advanced filter
     $entryFilter = new entryFilter();
     $entryFilter->setStatusEquel(entryStatus::READY);
     $entryFilter->setModerationStatusNot(entry::ENTRY_MODERATION_STATUS_REJECTED);
     $entryFilter->setPartnerSearchScope($this->getPartnerId());
     $entryFilter->setAdvancedSearch($distributionAdvancedSearch);
     return $entryFilter;
 }

 public function __construct($feedId)
 {
     myDbHelper::$use_alternative_con = myDbHelper::DB_HELPER_CONN_PROPEL3;
     $microTimeStart = microtime(true);
     KalturaLog::info("syndicationFeedRenderer- initialize ");
     // initialize the database for all services
     DbManager::setConfig(kConf::getDB());
     DbManager::initialize();
     $syndicationFeedDB = syndicationFeedPeer::retrieveByPK($feedId);
     if (!$syndicationFeedDB) {
         throw new Exception("Feed Id not found");
     }
     $tmpSyndicationFeed = KalturaSyndicationFeedFactory::getInstanceByType($syndicationFeedDB->getType());
     $tmpSyndicationFeed->fromObject($syndicationFeedDB);
     $this->syndicationFeed = $tmpSyndicationFeed;
     // add partner to default criteria
     categoryPeer::addPartnerToCriteria($this->syndicationFeed->partnerId, true);
     flavorAssetPeer::addPartnerToCriteria($this->syndicationFeed->partnerId, true);
     $this->baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $startDateCriterion = $this->baseCriteria->getNewCriterion(entryPeer::START_DATE, time(), Criteria::LESS_EQUAL);
     $startDateCriterion->addOr($this->baseCriteria->getNewCriterion(entryPeer::START_DATE, null));
     $this->baseCriteria->addAnd($startDateCriterion);
     $endDateCriterion = $this->baseCriteria->getNewCriterion(entryPeer::END_DATE, time(), Criteria::GREATER_EQUAL);
     $endDateCriterion->addOr($this->baseCriteria->getNewCriterion(entryPeer::END_DATE, null));
     $this->baseCriteria->addAnd($endDateCriterion);
     $entryFilter = new entryFilter();
     $entryFilter->setPartnerSearchScope($this->syndicationFeed->partnerId);
     $entryFilter->setStatusEquel(entryStatus::READY);
     $entryFilter->setTypeIn(array(entryType::MEDIA_CLIP, entryType::MIX));
     $entryFilter->setModerationStatusNot(entry::ENTRY_MODERATION_STATUS_REJECTED);
     $entryFilter->setDurationGreaterThan(0);
     $entryFilter->attachToCriteria($this->baseCriteria);
     if ($this->syndicationFeed->playlistId) {
         $this->entryFilters = myPlaylistUtils::getPlaylistFiltersById($this->syndicationFeed->playlistId);
     } else {
         $this->entryFilters = array();
     }
     $microTimeEnd = microtime(true);
     KalturaLog::info("syndicationFeedRenderer- initialization done [" . ($microTimeEnd - $microTimeStart) . "]");
 }

 private function getLicenseRequestEntry($keyId, $entryId = null)
 {
     $entry = null;
     $keyId = strtolower($keyId);
     if (!$keyId) {
         throw new KalturaAPIException(KalturaErrors::MISSING_MANDATORY_PARAMETER, "keyId");
     }
     if ($entryId) {
         $entry = entryPeer::retrieveByPK($entryId);
         if (!$entry) {
             throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
         }
         $entryKeyId = $this->getEntryKeyId($entry->getId());
         if ($entryKeyId != $keyId) {
             throw new KalturaAPIException(KalturaPlayReadyErrors::KEY_ID_DONT_MATCH, $keyId, $entryKeyId);
         }
     } else {
         $entryFilter = new entryFilter();
         $entryFilter->fields['_like_plugins_data'] = PlayReadyPlugin::getPlayReadyKeyIdSearchData($keyId);
         $entryFilter->setPartnerSearchScope(baseObjectFilter::MATCH_KALTURA_NETWORK_AND_PRIVATE);
         $c = KalturaCriteria::create(entryPeer::OM_CLASS);
         $entryFilter->attachToCriteria($c);
         $c->applyFilters();
         $entries = entryPeer::doSelect($c);
         if ($entries && count($entries) > 0) {
             $entry = $entries[0];
         }
         if (!$entry) {
             throw new KalturaAPIException(KalturaPlayReadyErrors::ENTRY_NOT_FOUND_BY_KEY_ID, $keyId);
         }
     }
     return $entry;
 }

 /**
  * @action getFeed
  * @disableTags TAG_WIDGET_SESSION,TAG_ENTITLEMENT_ENTRY,TAG_ENTITLEMENT_CATEGORY
  * @param int $distributionProfileId
  * @param string $hash
  * @return file
  */
 public function getFeedAction($distributionProfileId, $hash)
 {
     if (!$this->getPartnerId() || !$this->getPartner()) {
         throw new KalturaAPIException(KalturaErrors::INVALID_PARTNER_ID, $this->getPartnerId());
     }
     $profile = DistributionProfilePeer::retrieveByPK($distributionProfileId);
     if (!$profile || !$profile instanceof AttUverseDistributionProfile) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_NOT_FOUND, $distributionProfileId);
     }
     if ($profile->getStatus() != KalturaDistributionProfileStatus::ENABLED) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_DISABLED, $distributionProfileId);
     }
     if ($profile->getUniqueHashForFeedUrl() != $hash) {
         throw new KalturaAPIException(AttUverseDistributionErrors::INVALID_FEED_URL);
     }
     // "Creates advanced filter on distribution profile
     $distributionAdvancedSearch = new ContentDistributionSearchFilter();
     $distributionAdvancedSearch->setDistributionProfileId($profile->getId());
     $distributionAdvancedSearch->setDistributionSunStatus(EntryDistributionSunStatus::AFTER_SUNRISE);
     $distributionAdvancedSearch->setEntryDistributionStatus(EntryDistributionStatus::READY);
     $distributionAdvancedSearch->setEntryDistributionFlag(EntryDistributionDirtyStatus::NONE);
     $distributionAdvancedSearch->setHasEntryDistributionValidationErrors(false);
     //Creates entry filter with advanced filter
     $entryFilter = new entryFilter();
     $entryFilter->setStatusEquel(entryStatus::READY);
     $entryFilter->setModerationStatusNot(entry::ENTRY_MODERATION_STATUS_REJECTED);
     $entryFilter->setPartnerSearchScope($this->getPartnerId());
     $entryFilter->setAdvancedSearch($distributionAdvancedSearch);
     $baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $baseCriteria->add(entryPeer::DISPLAY_IN_SEARCH, mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM, Criteria::NOT_EQUAL);
     $entryFilter->attachToCriteria($baseCriteria);
     $entries = entryPeer::doSelect($baseCriteria);
     $feed = new AttUverseDistributionFeedHelper('feed_template.xml', $profile);
     $channelTitle = $profile->getChannelTitle();
     $counter = 0;
     foreach ($entries as $entry) {
         /* @var $entry entry */
         /* @var $entryDistribution Entrydistribution */
         $entryDistribution = EntryDistributionPeer::retrieveByEntryAndProfileId($entry->getId(), $profile->getId());
         if (!$entryDistribution) {
             KalturaLog::err('Entry distribution was not found for entry [' . $entry->getId() . '] and profile [' . $profile->getId() . ']');
             continue;
         }
         $fields = $profile->getAllFieldValues($entryDistribution);
         //flavors assets and remote flavor asset file urls
         $flavorAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getFromCustomData(AttUverseEntryDistributionCustomDataField::DISTRIBUTED_FLAVOR_IDS)));
         $remoteAssetFileUrls = unserialize($entryDistribution->getFromCustomData(AttUverseEntryDistributionCustomDataField::REMOTE_ASSET_FILE_URLS));
         //thumb assets and remote thumb asset file urls
         $thumbAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getFromCustomData(AttUverseEntryDistributionCustomDataField::DISTRIBUTED_THUMBNAIL_IDS)));
         $remoteThumbailFileUrls = unserialize($entryDistribution->getFromCustomData(AttUverseEntryDistributionCustomDataField::REMOTE_THUMBNAIL_FILE_URLS));
         //thumb assets and remote thumb asset file urls
         $captionAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getFromCustomData(AttUverseEntryDistributionCustomDataField::DISTRIBUTED_CAPTION_IDS)));
         $feed->addItem($fields, $flavorAssets, $remoteAssetFileUrls, $thumbAssets, $remoteThumbailFileUrls, $captionAssets);
         $counter++;
         //to avoid the cache exceeding the memory size
         if ($counter >= 100) {
             kMemoryManager::clearMemory();
             $counter = 0;
         }
     }
     //set channel title
     if (isset($fields)) {
         $channelTitle = $fields[AttUverseDistributionField::CHANNEL_TITLE];
     }
     $feed->setChannelTitle($channelTitle);
     header('Content-Type: text/xml');
     echo str_replace('&', '&', html_entity_decode($feed->getXml(), ENT_QUOTES, 'UTF-8'));
     die;
 }

 private static function executeQueryByType($partner_id, $report_type, $report_flavor, reportsInputFilter $input_filter, $page_size, $page_index, $order_by, $object_ids = null, $offset = null)
 {
     $start = microtime(true);
     try {
         $add_search_text = false;
         $has_object_ids = false;
         if ($input_filter instanceof endUserReportsInputFilter) {
             $has_object_ids = $input_filter->categories;
         }
         $has_object_ids = $has_object_ids || $object_ids;
         if (is_numeric($report_type)) {
             $file_path = myReportsSqlFileMgr::getSqlFilePath(self::$type_map[$report_type], self::$flavor_map[$report_flavor], $add_search_text, $has_object_ids ? true : false, $input_filter);
         } else {
             if (strpos($report_type, ".") === 0 || strpos($report_type, "/") === 0 || strpos($report_type, "http") === 0) {
                 throw new kCoreException("Will not search for invalid report_type [{$report_type}", kCoreException::INVALID_QUERY);
             }
             $file_path = dirname(__FILE__) . "/" . $report_type . ".sql";
         }
         $sql_raw_content = file_get_contents($file_path);
         if (!$sql_raw_content) {
             $pluginInstances = KalturaPluginManager::getPluginInstances('IKalturaReportProvider');
             foreach ($pluginInstances as $pluginInstance) {
                 $res = $pluginInstance->getReportResult($partner_id, $report_type, $report_flavor, $object_ids, $order_by);
                 if (!is_null($res)) {
                     return $res;
                 }
             }
             throw new kCoreException("Cannot find sql for [{$report_type}] [{$report_flavor}] at [{$file_path}]", kCoreException::QUERY_NOT_FOUND);
         }
         $entryFilter = new entryFilter();
         $entryFilter->setPartnerSearchScope($partner_id);
         $shouldSelectFromSearchEngine = false;
         $category_ids_clause = "1=1";
         if ($input_filter instanceof endUserReportsInputFilter) {
             if ($input_filter->playbackContext || $input_filter->ancestorPlaybackContext) {
                 $categoryFilter = new categoryFilter();
                 if ($input_filter->playbackContext && $input_filter->ancestorPlaybackContext) {
                     $categoryIds = category::CATEGORY_ID_THAT_DOES_NOT_EXIST;
                 } else {
                     if ($input_filter->playbackContext) {
                         $categoryFilter->set("_in_full_name", $input_filter->playbackContext);
                     }
                     if ($input_filter->ancestorPlaybackContext) {
                         $categoryFilter->set("_matchor_likex_full_name", $input_filter->ancestorPlaybackContext);
                     }
                     $c = KalturaCriteria::create(categoryPeer::OM_CLASS);
                     $categoryFilter->attachToCriteria($c);
                     $c->applyFilters();
                     $categoryIdsFromDB = $c->getFetchedIds();
                     if (count($categoryIdsFromDB)) {
                         $categoryIds = implode(",", $categoryIdsFromDB);
                     } else {
                         $categoryIds = category::CATEGORY_ID_THAT_DOES_NOT_EXIST;
                     }
                 }
                 $category_ids_clause = "ev.context_id in ( {$categoryIds} )";
             }
         }
         if ($input_filter->categories) {
             $entryFilter->set("_matchor_categories", $input_filter->categories);
             $shouldSelectFromSearchEngine = true;
         }
         if ($input_filter->keywords) {
             if ($input_filter->search_in_tags) {
                 $entryFilter->set("_free_text", $input_filter->keywords);
             } else {
                 $entryFilter->set("_like_admin_tags", $input_filter->keywords);
             }
             $shouldSelectFromSearchEngine = true;
         }
         $entryIdsFromDB = array();
         if ($shouldSelectFromSearchEngine) {
             $c = KalturaCriteria::create(entryPeer::OM_CLASS);
             $entryFilter->attachToCriteria($c);
             $c->applyFilters();
             $entryIdsFromDB = $c->getFetchedIds();
             if ($c->getRecordsCount() > count($entryIdsFromDB)) {
                 throw new kCoreException('Search is to general', kCoreException::SEARCH_TOO_GENERAL);
             }
             if (!count($entryIdsFromDB)) {
                 $entryIdsFromDB[] = entry::ENTRY_ID_THAT_DOES_NOT_EXIST;
             }
         }
         $obj_ids_clause = null;
         if ($object_ids) {
             //the object ids are not supposed to include single quotes - if they do have them - remove them
             $object_ids = str_replace("'", '', $object_ids);
             // quote all the objects with SINGLE-QUOTES
             $object_ids_str = "'" . str_replace(",", "','", $object_ids) . "'";
             if ($report_type == self::REPORT_TYPE_CONTENT_CONTRIBUTIONS) {
                 $obj_ids_clause = "en.entry_media_source_id in ( {$object_ids_str})";
             } else {
                 if ($report_type == self::REPORT_TYPE_TOP_SYNDICATION) {
                     $obj_ids_clause = "ev.domain_id in ( {$object_ids_str})";
                 } else {
                     if ($report_type == self::REPORT_TYPE_MAP_OVERLAY) {
                         $obj_ids_clause = "ev.country_id in ( {$object_ids_str})";
                     } else {
                         if ($report_type == self::REPORT_TYPE_ADMIN_CONSOLE) {
                             $obj_ids_clause = "dim_partner.partner_id in ( {$object_ids_str})";
//.........这里部分代码省略.........

 public function postInsert(PropelPDO $con = null)
 {
     parent::postInsert($con);
     if (!$this->getFeedId() || !$this->getId()) {
         return;
     }
     $podcastFeed = syndicationFeedPeer::retrieveByPK($this->getFeedId());
     if (!$podcastFeed || !$podcastFeed instanceof genericSyndicationFeed) {
         return;
     }
     // "Creates advanced filter on distribution profile
     $distributionAdvancedSearch = new ContentDistributionSearchFilter();
     $distributionAdvancedSearch->setDistributionProfileId($this->getId());
     $distributionAdvancedSearch->setDistributionSunStatus(EntryDistributionSunStatus::AFTER_SUNRISE);
     $distributionAdvancedSearch->setEntryDistributionStatus(EntryDistributionStatus::READY);
     $distributionAdvancedSearch->setEntryDistributionFlag(EntryDistributionDirtyStatus::NONE);
     //Creates entry filter with advanced filter
     $entryFilter = new entryFilter();
     $entryFilter->setPartnerSearchScope($this->getPartnerId());
     $entryFilter->setAdvancedSearch($distributionAdvancedSearch);
     // Creates playlist with entry filter
     $playlistXml = new SimpleXMLElement("<playlist/>");
     $filtersXml = $playlistXml->addChild("filters");
     $filterXml = $filtersXml->addChild("filter");
     $entryFilter->toXml($filterXml);
     $playlistContent = $playlistXml->asXML();
     // creates playlist based on the filter XML
     $playlist = new entry();
     $playlist->setKuserId(kCurrentContext::$uid);
     $playlist->setCreatorKuserId(kCurrentContext::$uid);
     $playlist->setDisplayInSearch(mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM);
     $playlist->setPartnerId($this->getPartnerId());
     $playlist->setStatus(entryStatus::READY);
     $playlist->setKshowId(null);
     $playlist->setType(entryType::PLAYLIST);
     $playlist->setMediaType(entry::ENTRY_MEDIA_TYPE_XML);
     $playlist->setDataContent($playlistContent);
     $playlist->save();
     KalturaLog::log("Playlist [" . $playlist->getId() . "] created");
     // creates feed based on the playlist
     $podcastFeed->setPlaylistId($playlist->getId());
     $podcastFeed->save();
 }

 public function addFilter(entryFilter $entryFilter)
 {
     if ($this->executed) {
         return;
     }
     $entryFilter->setPartnerSearchScope(baseObjectFilter::MATCH_KALTURA_NETWORK_AND_PRIVATE);
     // partner scope already attached
     $entryFilter->attachToCriteria($this->baseCriteria);
 }

 /**
  * reset category's directEntriesCount by calculate it.
  */
 public function reSetDirectEntriesCount()
 {
     $baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $filter = new entryFilter();
     $filter->setPartnerSearchScope(baseObjectFilter::MATCH_KALTURA_NETWORK_AND_PRIVATE);
     $filter->setCategoriesIdsMatchAnd($this->getId());
     $filter->setLimit(1);
     $filter->attachToCriteria($baseCriteria);
     $baseCriteria->applyFilters();
     $count = $baseCriteria->getRecordsCount();
     $this->setDirectEntriesCount($count);
 }

 /**
  * @param KalturaBaseEntryFilter $filter
  * @param KalturaFilterPager $pager
  * @param string $partnerIdForScope
  * @return KalturaCriteria
  */
 protected function prepareEntriesCriteriaFilter(KalturaBaseEntryFilter $filter = null, KalturaFilterPager $pager = null, $partnerIdForScope)
 {
     if (!$filter) {
         $filter = new KalturaBaseEntryFilter();
     }
     // because by default we will display only READY entries, and when deleted status is requested, we don't want this to disturb
     entryPeer::allowDeletedInCriteriaFilter();
     // when session is not admin, allow access to user entries only
     if (!$this->getKs() || !$this->getKs()->isAdmin()) {
         $filter->userIdEqual = $this->getKuser()->getPuserId();
     }
     $this->setDefaultStatus($filter);
     $this->setDefaultModerationStatus($filter);
     $this->fixFilterUserId($filter);
     $this->fixFilterDuration($filter);
     $entryFilter = new entryFilter();
     if (is_null($partnerIdForScope)) {
         $entryFilter->setPartnerSearchScope($this->getPartnerId());
     } else {
         $entryFilter->setPartnerSearchScope($partnerIdForScope);
     }
     $filter->toObject($entryFilter);
     $c = KalturaCriteria::create(entryPeer::OM_CLASS);
     if ($pager) {
         $pager->attachToCriteria($c);
     }
     $entryFilter->attachToCriteria($c);
     return $c;
 }

 /**
  * @action getFeed
  * @disableTags TAG_WIDGET_SESSION,TAG_ENTITLEMENT_ENTRY,TAG_ENTITLEMENT_CATEGORY
  * @param int $distributionProfileId
  * @param string $hash
  * @param int $page
  * @param int $period
  * @param string $state
  * @param bool $ignoreScheduling
  * @return file
  */
 public function getFeedAction($distributionProfileId, $hash, $page = 1, $period = -1, $state = '', $ignoreScheduling = false)
 {
     if (!$this->getPartnerId() || !$this->getPartner()) {
         throw new KalturaAPIException(KalturaErrors::INVALID_PARTNER_ID, $this->getPartnerId());
     }
     $profile = DistributionProfilePeer::retrieveByPK($distributionProfileId);
     /* @var $profile DoubleClickDistributionProfile */
     if (!$profile || !$profile instanceof DoubleClickDistributionProfile) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_NOT_FOUND, $distributionProfileId);
     }
     if ($profile->getStatus() != KalturaDistributionProfileStatus::ENABLED) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_DISABLED, $distributionProfileId);
     }
     if ($profile->getUniqueHashForFeedUrl() != $hash) {
         throw new KalturaAPIException(DoubleClickDistributionErrors::INVALID_FEED_URL);
     }
     if (!$page || $page < 1) {
         $page = 1;
     }
     $stateLastEntryCreatedAt = null;
     $stateLastEntryIds = array();
     if ($state) {
         $stateDecoded = base64_decode($state);
         if (strpos($stateDecoded, '|') !== false) {
             $stateExploded = explode('|', $stateDecoded);
             $stateLastEntryCreatedAt = $stateExploded[0];
             $stateLastEntryIdsStr = $stateExploded[1];
             $stateLastEntryIds = explode(',', $stateLastEntryIdsStr);
         }
     }
     // "Creates advanced filter on distribution profile
     $distributionAdvancedSearch = new ContentDistributionSearchFilter();
     $distributionAdvancedSearch->setDistributionProfileId($profile->getId());
     if ($ignoreScheduling !== true && $profile->getIgnoreSchedulingInFeed() !== true) {
         $distributionAdvancedSearch->setDistributionSunStatus(EntryDistributionSunStatus::AFTER_SUNRISE);
     }
     $distributionAdvancedSearch->setEntryDistributionStatus(EntryDistributionStatus::READY);
     $distributionAdvancedSearch->setEntryDistributionFlag(EntryDistributionDirtyStatus::NONE);
     $distributionAdvancedSearch->setHasEntryDistributionValidationErrors(false);
     // Creates entry filter with advanced filter
     $entryFilter = new entryFilter();
     $entryFilter->setStatusEquel(entryStatus::READY);
     $entryFilter->setModerationStatusNot(entry::ENTRY_MODERATION_STATUS_REJECTED);
     $entryFilter->setPartnerSearchScope($this->getPartnerId());
     $entryFilter->setAdvancedSearch($distributionAdvancedSearch);
     $entryFilter->set('_order_by', '-created_at');
     if ($period && $period > 0) {
         $entryFilter->set('_gte_updated_at', time() - 24 * 60 * 60);
     }
     // last 24 hours
     // Dummy query to get the total count
     $baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $baseCriteria->add(entryPeer::DISPLAY_IN_SEARCH, mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM, Criteria::NOT_EQUAL);
     $baseCriteria->setLimit(1);
     $entryFilter->attachToCriteria($baseCriteria);
     $entries = entryPeer::doSelect($baseCriteria);
     $totalCount = $baseCriteria->getRecordsCount();
     // Add the state data to proceed to next page
     if ($stateLastEntryCreatedAt) {
         $entryFilter->set('_lte_created_at', $stateLastEntryCreatedAt);
     }
     if ($stateLastEntryIds) {
         $entryFilter->set('_notin_id', $stateLastEntryIds);
     }
     $baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $baseCriteria->add(entryPeer::DISPLAY_IN_SEARCH, mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM, Criteria::NOT_EQUAL);
     $baseCriteria->setLimit($profile->getItemsPerPage() + 1);
     // get +1 to check if we have next page
     $entryFilter->attachToCriteria($baseCriteria);
     $entries = entryPeer::doSelect($baseCriteria);
     $hasNextPage = false;
     if (count($entries) === $profile->getItemsPerPage() + 1) {
         // we tried to get (itemsPerPage + 1) entries, meaning we have another page
         $hasNextPage = true;
         unset($entries[$profile->getItemsPerPage()]);
     }
     // Find the state
     $entryIds = array();
     $nextPageStateLastEntryCreatedAt = $stateLastEntryCreatedAt;
     $nextPageStateLastEntryIds = $stateLastEntryIds;
     foreach ($entries as $entry) {
         $entryIds[] = $entry->getId();
         if ($nextPageStateLastEntryCreatedAt > $entry->getCreatedAt(null)) {
             $nextPageStateLastEntryIds = array();
         }
         $nextPageStateLastEntryIds[] = $entry->getId();
         $nextPageStateLastEntryCreatedAt = $entry->getCreatedAt(null);
     }
     // Construct the feed
//.........这里部分代码省略.........

 /**
  * @action getFeed
  * @disableTags TAG_WIDGET_SESSION,TAG_ENTITLEMENT_ENTRY,TAG_ENTITLEMENT_CATEGORY
  * @param int $distributionProfileId
  * @param string $hash
  * @return file
  */
 public function getFeedAction($distributionProfileId, $hash)
 {
     if (!$this->getPartnerId() || !$this->getPartner()) {
         throw new KalturaAPIException(KalturaErrors::INVALID_PARTNER_ID, $this->getPartnerId());
     }
     $profile = DistributionProfilePeer::retrieveByPK($distributionProfileId);
     if (!$profile || !$profile instanceof UverseClickToOrderDistributionProfile) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_NOT_FOUND, $distributionProfileId);
     }
     if ($profile->getStatus() != KalturaDistributionProfileStatus::ENABLED) {
         throw new KalturaAPIException(ContentDistributionErrors::DISTRIBUTION_PROFILE_DISABLED, $distributionProfileId);
     }
     if ($profile->getUniqueHashForFeedUrl() != $hash) {
         throw new KalturaAPIException(UverseClickToOrderDistributionErrors::INVALID_FEED_URL);
     }
     // "Creates advanced filter on distribution profile
     $distributionAdvancedSearch = new ContentDistributionSearchFilter();
     $distributionAdvancedSearch->setDistributionProfileId($profile->getId());
     $distributionAdvancedSearch->setDistributionSunStatus(EntryDistributionSunStatus::AFTER_SUNRISE);
     $distributionAdvancedSearch->setEntryDistributionStatus(EntryDistributionStatus::READY);
     $distributionAdvancedSearch->setEntryDistributionFlag(EntryDistributionDirtyStatus::NONE);
     $distributionAdvancedSearch->setHasEntryDistributionValidationErrors(false);
     //Creates entry filter with advanced filter
     $entryFilter = new entryFilter();
     $entryFilter->setStatusEquel(entryStatus::READY);
     $entryFilter->setModerationStatusNot(entry::ENTRY_MODERATION_STATUS_REJECTED);
     $entryFilter->setPartnerSearchScope($this->getPartnerId());
     $entryFilter->setAdvancedSearch($distributionAdvancedSearch);
     $baseCriteria = KalturaCriteria::create(entryPeer::OM_CLASS);
     $baseCriteria->add(entryPeer::DISPLAY_IN_SEARCH, mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM, Criteria::NOT_EQUAL);
     $entryFilter->attachToCriteria($baseCriteria);
     $baseCriteria->addDescendingOrderByColumn(entryPeer::UPDATED_AT);
     $entries = entryPeer::doSelect($baseCriteria);
     $feed = new UverseClickToOrderFeed('feed_template.xml');
     $feed->setDistributionProfile($profile);
     //setting background images
     $wideBackgroundImageEntryId = $profile->getBackgroundImageWide();
     $standardBackgroundImageEntryId = $profile->getBackgroundImageStandard();
     $widedBackgroundImageUrl = $this->getImageUrl($wideBackgroundImageEntryId, '854', '480');
     $standardBackgroundImageUrl = $this->getImageUrl($standardBackgroundImageEntryId, '640', '480');
     $feed->setBackgroudImage($widedBackgroundImageUrl, $standardBackgroundImageUrl);
     //getting array of all related entries (categories that will appear in the xml)
     $relatedEntriesArray = array();
     //going through all entries and preparing an array with all related entries (categories) directing to the entires
     foreach ($entries as $entry) {
         $entryDistribution = EntryDistributionPeer::retrieveByEntryAndProfileId($entry->getId(), $profile->getId());
         if (!$entryDistribution) {
             KalturaLog::err('Entry distribution was not found for entry [' . $entry->getId() . '] and profile [' . $profile->getId() . ']');
             continue;
         }
         $fields = $profile->getAllFieldValues($entryDistribution);
         $relatedEntryId = $fields[UverseClickToOrderDistributionField::CATEGORY_ENTRY_ID];
         if (!isset($relatedEntriesArray[$relatedEntryId])) {
             $relatedEntry = entryPeer::retrieveByPK($relatedEntryId);
             $relatedEntrySortValue = $this->getRelatedEntrySortValue($profile, $relatedEntryId);
             $relatedEntriesArray[$relatedEntryId] = array();
             $relatedEntriesArray[$relatedEntryId]['sortValue'] = $relatedEntrySortValue;
             $relatedEntriesArray[$relatedEntryId]['updatedAt'] = $relatedEntry->getUpdatedAt();
             $relatedEntriesArray[$relatedEntryId]['relatedEntryId'] = $relatedEntryId;
         }
         $flavorAssets = array_map('trim', explode(',', $entryDistribution->getFlavorAssetIds()));
         $flavorAssetId = isset($flavorAssets[0]) ? $flavorAssets[0] : null;
         $flavorAsset = assetPeer::retrieveById($flavorAssetId);
         $flavorUrl = $flavorAsset ? $flavorAsset->getDownloadUrl() : $entry->getDownloadUrl();
         $thumbAssets = array_map('trim', explode(',', $entryDistribution->getThumbAssetIds()));
         $thumbAssetId = isset($thumbAssets[0]) ? $thumbAssets[0] : null;
         $thumbAsset = assetPeer::retrieveById($thumbAssetId);
         $thumbUrl = $thumbAsset ? $thumbAsset->getDownloadUrl() : $entry->getThumbnailUrl();
         $relatedEntriesArray[$relatedEntryId][] = array('id' => $entry->getId(), 'thumbnailUrl' => $thumbUrl, 'downloadUrl' => $flavorUrl, 'updatedAt' => $entry->getUpdatedAt(), 'sortValue' => $profile->getFieldValue($entryDistribution, UverseClickToOrderDistributionField::SORT_ITEMS_BY_FIELD));
     }
     //sorting the related entries.
     usort($relatedEntriesArray, array($this, 'sortItems'));
     //removing the values that where used for sorting.
     foreach ($relatedEntriesArray as $key => $relatedEntry) {
         $relatedEntryId = $relatedEntry['relatedEntryId'];
         unset($relatedEntry['relatedEntryId']);
         unset($relatedEntry['sortValue']);
         unset($relatedEntry['updatedAt']);
         unset($relatedEntriesArray[$key]);
         $relatedEntriesArray[$relatedEntryId] = $relatedEntry;
     }
     //retreive each category and add it to the xml
     foreach ($relatedEntriesArray as $relatedEntryId => $entriesUnderCategory) {
         //getting the related entry id object
         $relatedEntryObject = entryPeer::retrieveByPK($relatedEntryId);
         if (!$relatedEntryObject) {
             KalturaLog::err('Related Entry [' . $relatedEntryId . '] was not found');
             continue;
         }
         $categoryName = $relatedEntryObject->getName();
         $categoryFile = $relatedEntryObject->getThumbnailUrl() . '/width/' . $fields[UverseClickToOrderDistributionField::CATEGORY_IMAGE_WIDTH] . '/height/' . $fields[UverseClickToOrderDistributionField::CATEGORY_IMAGE_HEIGHT];
         $categoryNode = $feed->addCategory($categoryName, $categoryFile);
         usort($entriesUnderCategory, array($this, 'sortItems'));
//.........这里部分代码省略.........

 /**
  * @param KalturaBaseEntryFilter $filter
  * @param KalturaFilterPager $pager
  * @return KalturaCriteria
  */
 protected function prepareEntriesCriteriaFilter(KalturaBaseEntryFilter $filter = null, KalturaFilterPager $pager = null)
 {
     if (!$filter) {
         $filter = new KalturaBaseEntryFilter();
     }
     // because by default we will display only READY entries, and when deleted status is requested, we don't want this to disturb
     entryPeer::allowDeletedInCriteriaFilter();
     $this->setDefaultStatus($filter);
     $this->setDefaultModerationStatus($filter);
     $this->fixFilterUserId($filter);
     $this->fixFilterDuration($filter);
     $entryFilter = new entryFilter();
     $entryFilter->setPartnerSearchScope(baseObjectFilter::MATCH_KALTURA_NETWORK_AND_PRIVATE);
     $filter->toObject($entryFilter);
     $c = KalturaCriteria::create(entryPeer::OM_CLASS);
     if ($pager) {
         $pager->attachToCriteria($c);
     }
     $entryFilter->attachToCriteria($c);
     $c->add(entryPeer::DISPLAY_IN_SEARCH, mySearchUtils::DISPLAY_IN_SEARCH_SYSTEM, Criteria::NOT_EQUAL);
     // when session is not admin and without list:* privilege, allow access to user entries only
     //moved to Additional criteria on entryPeer
     //moved it init service.
     /*if (!$this->getKs() || (!$this->getKs()->isAdmin() && !$this->getKs()->verifyPrivileges(ks::PRIVILEGE_LIST, ks::PRIVILEGE_WILDCARD)))
     		{
     			KalturaCriterion::enableTag(KalturaCriterion::TAG_WIDGET_SESSION);*/
     /*$filter->userIdEqual = $this->getKuser()->getPuserId();
     		
     			$crit = $c->getNewCriterion(entryPeer::KUSER_ID , $this->getKuser()->getId(), Criteria::EQUAL);
     			$c->addAnd($crit);*/
     /*}*/
     return $c;
 }