PHP KalturaPluginManager::getExtendedTypes方法代码示例

 /**
  * List thumb params output objects by filter and pager
  * 
  * @action list
  * @param KalturaThumbParamsOutputFilter $filter
  * @param KalturaFilterPager $pager
  * @return KalturaThumbParamsOutputListResponse
  */
 function listAction(KalturaThumbParamsOutputFilter $filter = null, KalturaFilterPager $pager = null)
 {
     if (!$filter) {
         $filter = new KalturaThumbParamsOutputFilter();
     }
     if (!$pager) {
         $pager = new KalturaFilterPager();
     }
     $types = KalturaPluginManager::getExtendedTypes(assetParamsOutputPeer::OM_CLASS, assetType::THUMBNAIL);
     return $filter->getTypeListResponse($pager, $this->getResponseProfile(), $types);
 }

 public function initService($serviceId, $serviceName, $actionName)
 {
     parent::initService($serviceId, $serviceName, $actionName);
     parent::applyPartnerFilterForClass(new conversionProfile2Peer());
     parent::applyPartnerFilterForClass(new assetParamsOutputPeer());
     $fullActionName = "{$serviceName}.{$actionName}";
     if (!in_array($fullActionName, array('flavorAsset.getByEntryId', 'flavorAsset.getWebPlayableByEntryId', 'flavorAsset.list'))) {
         parent::applyPartnerFilterForClass(new assetPeer());
     }
     parent::applyPartnerFilterForClass(new assetParamsPeer());
     $this->mediaTypes = KalturaPluginManager::getExtendedTypes(entryPeer::OM_CLASS, KalturaEntryType::MEDIA_CLIP);
 }

 /**
  * List flavor params output objects by filter and pager
  * 
  * @action list
  * @param KalturaFlavorParamsOutputFilter $filter
  * @param KalturaFilterPager $pager
  * @return KalturaFlavorParamsOutputListResponse
  */
 function listAction(KalturaFlavorParamsOutputFilter $filter = null, KalturaFilterPager $pager = null)
 {
     if (!$filter) {
         $filter = new KalturaFlavorParamsOutputFilter();
     }
     if (!$pager) {
         $pager = new KalturaFilterPager();
     }
     $flavorParamsOutputFilter = new assetParamsOutputFilter();
     $filter->toObject($flavorParamsOutputFilter);
     $c = new Criteria();
     $flavorParamsOutputFilter->attachToCriteria($c);
     $flavorTypes = KalturaPluginManager::getExtendedTypes(assetParamsOutputPeer::OM_CLASS, assetType::FLAVOR);
     $c->add(assetParamsOutputPeer::TYPE, $flavorTypes, Criteria::IN);
     $totalCount = assetParamsOutputPeer::doCount($c);
     $pager->attachToCriteria($c);
     $dbList = assetParamsOutputPeer::doSelect($c);
     $list = KalturaFlavorParamsOutputArray::fromDbArray($dbList);
     $response = new KalturaFlavorParamsOutputListResponse();
     $response->objects = $list;
     $response->totalCount = $totalCount;
     return $response;
 }

 /**
  * List Thumb Params by filter with paging support (By default - all system default params will be listed too)
  * 
  * @action list
  * @param KalturaThumbParamsFilter $filter
  * @param KalturaFilterPager $pager
  * @return KalturaThumbParamsListResponse
  */
 public function listAction(KalturaThumbParamsFilter $filter = null, KalturaFilterPager $pager = null)
 {
     if (!$filter) {
         $filter = new KalturaThumbParamsFilter();
     }
     if (!$pager) {
         $pager = new KalturaFilterPager();
     }
     $thumbParamsFilter = new assetParamsFilter();
     $filter->toObject($thumbParamsFilter);
     $c = new Criteria();
     $thumbParamsFilter->attachToCriteria($c);
     $pager->attachToCriteria($c);
     $thumbTypes = KalturaPluginManager::getExtendedTypes(assetParamsPeer::OM_CLASS, assetType::THUMBNAIL);
     $c->add(assetParamsPeer::TYPE, $thumbTypes, Criteria::IN);
     $dbList = assetParamsPeer::doSelect($c);
     $c->setLimit(null);
     $totalCount = assetParamsPeer::doCount($c);
     $list = KalturaThumbParamsArray::fromDbArray($dbList);
     $response = new KalturaThumbParamsListResponse();
     $response->objects = $list;
     $response->totalCount = $totalCount;
     return $response;
 }

 public static function retrieveAllFlavorParamsTypes()
 {
     $flavorTypes = KalturaPluginManager::getExtendedTypes(self::OM_CLASS, assetType::FLAVOR);
     $flavorTypes[] = assetType::LIVE;
     return $flavorTypes;
 }

 public function getListResponse(KalturaFilterPager $pager, KalturaDetachedResponseProfile $responseProfile = null)
 {
     $types = KalturaPluginManager::getExtendedTypes(assetPeer::OM_CLASS, assetType::LIVE);
     return $this->getTypeListResponse($pager, $responseProfile, $types);
 }

 /**
  * List attachment Assets by filter and pager
  * 
  * @action list
  * @param KalturaAssetFilter $filter
  * @param KalturaFilterPager $pager
  * @return KalturaAttachmentAssetListResponse
  */
 function listAction(KalturaAssetFilter $filter = null, KalturaFilterPager $pager = null)
 {
     if (!$filter) {
         $filter = new KalturaAttachmentAssetFilter();
     } elseif (!$filter instanceof KalturaAttachmentAssetFilter) {
         $filter = $filter->cast('KalturaAttachmentAssetFilter');
     }
     if (!$pager) {
         $pager = new KalturaFilterPager();
     }
     $types = KalturaPluginManager::getExtendedTypes(assetPeer::OM_CLASS, AttachmentPlugin::getAssetTypeCoreValue(AttachmentAssetType::ATTACHMENT));
     return $filter->getTypeListResponse($pager, $this->getResponseProfile(), $types);
 }

 /**
  * Returns all live delivery profile types
  * @return array supported live types
  */
 public static function getAllLiveDeliveryProfileTypes()
 {
     $deliveryProfileTypes = KalturaPluginManager::getExtendedTypes(self::OM_CLASS, self::LIVE_DELIVERY_PROFILE);
     $deliveryProfileTypes = array_merge($deliveryProfileTypes, self::$LIVE_DELIVERY_PROFILES);
     $key = array_search(self::LIVE_DELIVERY_PROFILE, $deliveryProfileTypes);
     unset($deliveryProfileTypes[$key]);
     return $deliveryProfileTypes;
 }

 /**
  * Get Flavor Asset with the relevant Flavor Params (Flavor Params can exist without Flavor Asset & vice versa)
  * 
  * @action getFlavorAssetsWithParams
  * @param string $entryId
  * @return KalturaFlavorAssetWithParamsArray
  */
 public function getFlavorAssetsWithParamsAction($entryId)
 {
     $dbEntry = entryPeer::retrieveByPK($entryId);
     if (!$dbEntry) {
         throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $entryId);
     }
     // get all the flavor params of partner 0 and the current partner (note that partner 0 is defined as partner group in service.ct)
     $c = new Criteria();
     $flavorTypes = KalturaPluginManager::getExtendedTypes(assetParamsPeer::OM_CLASS, assetType::FLAVOR);
     $c->add(assetParamsPeer::TYPE, $flavorTypes, Criteria::IN);
     $flavorParamsDb = assetParamsPeer::doSelect($c);
     // get the flavor assets for this entry
     $c = new Criteria();
     $flavorTypes = KalturaPluginManager::getExtendedTypes(assetPeer::OM_CLASS, assetType::FLAVOR);
     $c->add(assetPeer::TYPE, $flavorTypes, Criteria::IN);
     $c->add(assetPeer::ENTRY_ID, $entryId);
     $c->add(assetPeer::STATUS, array(flavorAsset::FLAVOR_ASSET_STATUS_DELETED, flavorAsset::FLAVOR_ASSET_STATUS_TEMP), Criteria::NOT_IN);
     $flavorAssetsDb = assetPeer::doSelect($c);
     // find what flavot params are required
     $requiredFlavorParams = array();
     foreach ($flavorAssetsDb as $item) {
         $requiredFlavorParams[$item->getFlavorParamsId()] = true;
     }
     // now merge the results, first organize the flavor params in an array with the id as the key
     $flavorParamsArray = array();
     foreach ($flavorParamsDb as $item) {
         $flavorParams = $item->getId();
         $flavorParamsArray[$flavorParams] = $item;
         if (isset($requiredFlavorParams[$flavorParams])) {
             unset($requiredFlavorParams[$flavorParams]);
         }
     }
     // adding missing required flavors params to the list
     if (count($requiredFlavorParams)) {
         $flavorParamsDb = assetParamsPeer::retrieveByPKsNoFilter(array_keys($requiredFlavorParams));
         foreach ($flavorParamsDb as $item) {
             $flavorParamsArray[$item->getId()] = $item;
         }
     }
     $usedFlavorParams = array();
     // loop over the flavor assets and add them, if it has flavor params add them too
     $flavorAssetWithParamsArray = new KalturaFlavorAssetWithParamsArray();
     foreach ($flavorAssetsDb as $flavorAssetDb) {
         $flavorParamsId = $flavorAssetDb->getFlavorParamsId();
         $flavorAssetWithParams = new KalturaFlavorAssetWithParams();
         $flavorAssetWithParams->entryId = $entryId;
         $flavorAsset = new KalturaFlavorAsset();
         $flavorAsset->fromObject($flavorAssetDb);
         $flavorAssetWithParams->flavorAsset = $flavorAsset;
         if (isset($flavorParamsArray[$flavorParamsId])) {
             $flavorParamsDb = $flavorParamsArray[$flavorParamsId];
             $flavorParams = KalturaFlavorParamsFactory::getFlavorParamsInstance($flavorParamsDb->getType());
             $flavorParams->fromObject($flavorParamsDb);
             $flavorAssetWithParams->flavorParams = $flavorParams;
             // we want to log which flavor params are in use, there could be more
             // than one flavor asset using same params
             $usedFlavorParams[$flavorParamsId] = $flavorParamsId;
         }
         //			else if ($flavorAssetDb->getIsOriginal())
         //			{
         //				// create a dummy flavor params
         //				$flavorParams = new KalturaFlavorParams();
         //				$flavorParams->name = "Original source";
         //				$flavorAssetWithParams->flavorParams = $flavorParams;
         //			}
         $flavorAssetWithParamsArray[] = $flavorAssetWithParams;
     }
     // copy the remaining params
     foreach ($flavorParamsArray as $flavorParamsId => $flavorParamsDb) {
         if (isset($usedFlavorParams[$flavorParamsId])) {
             // flavor params already exists for a flavor asset, not need
             // to list it one more time
             continue;
         }
         $flavorParams = KalturaFlavorParamsFactory::getFlavorParamsInstance($flavorParamsDb->getType());
         $flavorParams->fromObject($flavorParamsDb);
         $flavorAssetWithParams = new KalturaFlavorAssetWithParams();
         $flavorAssetWithParams->entryId = $entryId;
         $flavorAssetWithParams->flavorParams = $flavorParams;
         $flavorAssetWithParamsArray[] = $flavorAssetWithParams;
     }
     return $flavorAssetWithParamsArray;
 }

 /**
  * @var array of all entry types that extend from media
  */
 protected function getEnabledMediaTypes()
 {
     $mediaTypes = KalturaPluginManager::getExtendedTypes(entryPeer::OM_CLASS, KalturaEntryType::MEDIA_CLIP);
     return $mediaTypes;
 }

 /**
  * List Thumbnail Assets by filter and pager
  * 
  * @action list
  * @param KalturaAssetFilter $filter
  * @param KalturaFilterPager $pager
  * @return KalturaThumbAssetListResponse
  */
 function listAction(KalturaAssetFilter $filter = null, KalturaFilterPager $pager = null)
 {
     if (!$filter) {
         $filter = new KalturaThumbAssetFilter();
     } elseif (!$filter instanceof KalturaThumbAssetFilter) {
         if (!is_subclass_of('KalturaThumbAssetFilter', get_class($filter))) {
             $filter = $filter->cast('KalturaAssetFilter');
         }
         $filter = $filter->cast('KalturaThumbAssetFilter');
     }
     if (!$pager) {
         $pager = new KalturaFilterPager();
     }
     $types = KalturaPluginManager::getExtendedTypes(assetPeer::OM_CLASS, assetType::THUMBNAIL);
     return $filter->getTypeListResponse($pager, $this->getResponseProfile(), $types);
 }

 /**
  * List Caption Params by filter with paging support (By default - all system default params will be listed too)
  * 
  * @action list
  * @param KalturaCaptionParamsFilter $filter
  * @param KalturaFilterPager $pager
  * @return KalturaCaptionParamsListResponse
  */
 public function listAction(KalturaCaptionParamsFilter $filter = null, KalturaFilterPager $pager = null)
 {
     if (!$filter) {
         $filter = new KalturaCaptionParamsFilter();
     }
     if (!$pager) {
         $pager = new KalturaFilterPager();
     }
     $types = KalturaPluginManager::getExtendedTypes(assetParamsPeer::OM_CLASS, CaptionPlugin::getAssetTypeCoreValue(CaptionAssetType::CAPTION));
     return $filter->getTypeListResponse($pager, $this->getResponseProfile(), $types);
 }

 public static function retrieveReadyThumbnailsByEntryId($entryId, array $paramsIds = null)
 {
     $c = new Criteria();
     $c->add(assetPeer::ENTRY_ID, $entryId);
     $c->add(assetPeer::STATUS, flavorAsset::FLAVOR_ASSET_STATUS_READY);
     if (count($paramsIds)) {
         $c->add(assetPeer::FLAVOR_PARAMS_ID, $paramsIds, Criteria::IN);
     }
     $flavorTypes = KalturaPluginManager::getExtendedTypes(self::OM_CLASS, assetType::THUMBNAIL);
     $c->add(assetPeer::TYPE, $flavorTypes, Criteria::IN);
     return self::doSelect($c);
 }

 public function contribute(BaseObject $object, SimpleXMLElement $mrss, kMrssParameters $mrssParams = null)
 {
     if (!$object instanceof entry) {
         return;
     }
     $types = KalturaPluginManager::getExtendedTypes(assetPeer::OM_CLASS, AttachmentPlugin::getAssetTypeCoreValue(AttachmentAssetType::ATTACHMENT));
     $attachmentAssets = assetPeer::retrieveByEntryId($object->getId(), $types);
     foreach ($attachmentAssets as $attachmentAsset) {
         $this->contributeAttachmentAssets($attachmentAsset, $mrss);
     }
 }

 public function getListResponse(KalturaFilterPager $pager, KalturaDetachedResponseProfile $responseProfile = null)
 {
     $types = KalturaPluginManager::getExtendedTypes(assetPeer::OM_CLASS, AttachmentPlugin::getAssetTypeCoreValue(AttachmentAssetType::ATTACHMENT));
     return $this->getTypeListResponse($pager, $responseProfile, $types);
 }