PHP assetPeer::retrieveReadyFlavorsByEntryId方法代码示例

 public function validateForSubmission(EntryDistribution $entryDistribution, $action)
 {
     $validationErrors = parent::validateForSubmission($entryDistribution, $action);
     $inListOrNullFields = array(FacebookDistributionField::CALL_TO_ACTION_TYPE_VALID_VALUES => explode(',', self::CALL_TO_ACTION_TYPE_VALID_VALUES));
     if (count($entryDistribution->getFlavorAssetIds())) {
         $flavorAssets = assetPeer::retrieveByIds(explode(',', $entryDistribution->getFlavorAssetIds()));
     } else {
         $flavorAssets = assetPeer::retrieveReadyFlavorsByEntryId($entryDistribution->getEntryId());
     }
     $validVideo = false;
     foreach ($flavorAssets as $flavorAsset) {
         $validVideo = $this->validateVideo($flavorAsset);
         if ($validVideo) {
             // even one valid video is enough
             break;
         }
     }
     if (!$validVideo) {
         KalturaLog::err("No valid video found for entry [" . $entryDistribution->getEntryId() . "]");
         $validationErrors[] = $this->createCustomValidationError($action, DistributionErrorType::INVALID_DATA, 'flavorAsset', ' No valid flavor found');
     }
     $allFieldValues = $this->getAllFieldValues($entryDistribution);
     if (!$allFieldValues || !is_array($allFieldValues)) {
         KalturaLog::err('Error getting field values from entry distribution id [' . $entryDistribution->getId() . '] profile id [' . $this->getId() . ']');
         return $validationErrors;
     }
     if ($allFieldValues[FacebookDistributionField::SCHEDULE_PUBLISHING_TIME] && $allFieldValues[FacebookDistributionField::SCHEDULE_PUBLISHING_TIME] > time() && !dateUtils::isWithinTimeFrame($allFieldValues[FacebookDistributionField::SCHEDULE_PUBLISHING_TIME], FacebookConstants::FACEBOOK_MIN_POSTPONE_POST_IN_SECONDS, FacebookConstants::FACEBOOK_MAX_POSTPONE_POST_IN_SECONDS)) {
         KalturaLog::err("Scheduled time to publish defies the facebook restriction of six minute to six months from now got" . $allFieldValues[FacebookDistributionField::SCHEDULE_PUBLISHING_TIME]);
         $validationErrors[] = $this->createCustomValidationError($action, DistributionErrorType::INVALID_DATA, 'sunrise', 'Distribution sunrise is invalid (should be 6 minutes to 6 months from now)');
     }
     $validationErrors = array_merge($validationErrors, $this->validateInListOrNull($inListOrNullFields, $allFieldValues, $action));
     return $validationErrors;
 }

 if ($lastCreatedAt) {
     $c->addAnd(entryPeer::CREATED_AT, $lastCreatedAt, Criteria::LESS_EQUAL);
 }
 $c->addDescendingOrderByColumn(entryPeer::CREATED_AT);
 $c->setLimit($curLimit);
 $entries = entryPeer::doSelect($c, myDbHelper::getConnection(myDbHelper::DB_HELPER_CONN_PROPEL3));
 foreach ($entries as $entry) {
     if (in_array($entry->getId(), $processedIds)) {
         continue;
     }
     $processedIds[] = $entry->getId();
     $lastCreatedAt = $entry->getCreatedAt(null);
     $keys = array();
     $keys[] = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_ISM);
     $keys[] = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_ISMC);
     $flavors = assetPeer::retrieveReadyFlavorsByEntryId($entry->getId());
     foreach ($flavors as $flavor) {
         if (!$flavorParamsArr || in_array($flavor->getFlavorParamsId(), $flavorParamsArr)) {
             $keys[] = $flavor->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
         }
     }
     foreach ($keys as $index => $key) {
         if (!kFileSyncUtils::fileSync_exists($key)) {
             unset($keys[$index]);
             continue;
         }
         if (kFileSyncUtils::getReadyExternalFileSyncForKey($key, $storageProfileId)) {
             unset($keys[$index]);
         }
         if (!kFileSyncUtils::getReadyInternalFileSyncForKey($key)) {
             echo 'file sync key does not have an internal file -' . serialize($key) . PHP_EOL;

 /**
  * @param kLiveEntryResource $resource
  * @param entry $dbEntry
  * @param asset $dbAsset
  * @return array $operationAttributes
  * @return asset
  */
 protected function attachLiveEntryResource(kLiveEntryResource $resource, entry $dbEntry, asset $dbAsset = null, array $operationAttributes = null)
 {
     $dbEntry->setRootEntryId($resource->getEntry()->getId());
     $dbEntry->setSource(EntrySourceType::RECORDED_LIVE);
     $dbEntry->save();
     if (!$dbAsset) {
         $dbAsset = kFlowHelper::createOriginalFlavorAsset($this->getPartnerId(), $dbEntry->getId());
     }
     $offset = null;
     $duration = null;
     $requiredDuration = null;
     $clipAttributes = null;
     if (is_array($operationAttributes)) {
         foreach ($operationAttributes as $operationAttributesItem) {
             if ($operationAttributesItem instanceof kClipAttributes) {
                 $clipAttributes = $operationAttributesItem;
                 // convert milliseconds to seconds
                 $offset = $operationAttributesItem->getOffset();
                 $duration = $operationAttributesItem->getDuration();
                 $requiredDuration = $offset + $duration;
             }
         }
     }
     $dbLiveEntry = $resource->getEntry();
     $dbRecordedEntry = entryPeer::retrieveByPK($dbLiveEntry->getRecordedEntryId());
     if (!$dbRecordedEntry || $requiredDuration && $requiredDuration > $dbRecordedEntry->getLengthInMsecs()) {
         $mediaServer = $dbLiveEntry->getMediaServer(true);
         if (!$mediaServer) {
             throw new KalturaAPIException(KalturaErrors::NO_MEDIA_SERVER_FOUND, $dbLiveEntry->getId());
         }
         $mediaServerLiveService = $mediaServer->getWebService($mediaServer->getLiveWebServiceName());
         if ($mediaServerLiveService && $mediaServerLiveService instanceof KalturaMediaServerLiveService) {
             $mediaServerLiveService->splitRecordingNow($dbLiveEntry->getId());
             $dbLiveEntry->attachPendingMediaEntry($dbEntry, $requiredDuration, $offset, $duration);
             $dbLiveEntry->save();
         } else {
             throw new KalturaAPIException(KalturaErrors::MEDIA_SERVER_SERVICE_NOT_FOUND, $mediaServer->getId(), $mediaServer->getLiveWebServiceName());
         }
         return $dbAsset;
     }
     $dbRecordedAsset = assetPeer::retrieveOriginalReadyByEntryId($dbRecordedEntry->getId());
     if (!$dbRecordedAsset) {
         $dbRecordedAssets = assetPeer::retrieveReadyFlavorsByEntryId($dbRecordedEntry->getId());
         $dbRecordedAsset = array_pop($dbRecordedAssets);
     }
     /* @var $dbRecordedAsset flavorAsset */
     $isNewAsset = false;
     if (!$dbAsset) {
         $isNewAsset = true;
         $dbAsset = kFlowHelper::createOriginalFlavorAsset($this->getPartnerId(), $dbEntry->getId());
     }
     if (!$dbAsset && $dbEntry->getStatus() == entryStatus::NO_CONTENT) {
         $dbEntry->setStatus(entryStatus::ERROR_CONVERTING);
         $dbEntry->save();
     }
     $sourceSyncKey = $dbRecordedAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
     $dbAsset->setFileExt($dbRecordedAsset->getFileExt());
     $dbAsset->save();
     $syncKey = $dbAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
     try {
         kFileSyncUtils::createSyncFileLinkForKey($syncKey, $sourceSyncKey);
     } catch (Exception $e) {
         if ($dbEntry->getStatus() == entryStatus::NO_CONTENT) {
             $dbEntry->setStatus(entryStatus::ERROR_CONVERTING);
             $dbEntry->save();
         }
         $dbAsset->setStatus(flavorAsset::FLAVOR_ASSET_STATUS_ERROR);
         $dbAsset->save();
         throw $e;
     }
     if ($requiredDuration) {
         $errDescription = '';
         kBusinessPreConvertDL::decideAddEntryFlavor(null, $dbEntry->getId(), $clipAttributes->getAssetParamsId(), $errDescription, $dbAsset->getId(), array($clipAttributes));
     } else {
         if ($isNewAsset) {
             kEventsManager::raiseEvent(new kObjectAddedEvent($dbAsset));
         }
     }
     kEventsManager::raiseEvent(new kObjectDataChangedEvent($dbAsset));
     return $dbAsset;
 }

 public static function checkForPendingLiveClips(entry $entry)
 {
     if ($entry->getSource() != EntrySourceType::RECORDED_LIVE) {
         KalturaLog::notice("Entry [" . $entry->getId() . "] is not a recorded live");
         return;
     }
     $liveEntry = entryPeer::retrieveByPKNoFilter($entry->getRootEntryId());
     if (!$liveEntry || $liveEntry->getStatus() == entryStatus::DELETED || !$liveEntry instanceof LiveEntry) {
         KalturaLog::notice("Entry root [" . $entry->getRootEntryId() . "] is not a valid live entry");
         return;
     }
     /* @var $liveEntry LiveEntry */
     $pendingMediaEntries = $liveEntry->getAttachedPendingMediaEntries();
     foreach ($pendingMediaEntries as $pendingMediaEntry) {
         /* @var $pendingMediaEntry kPendingMediaEntry */
         if ($pendingMediaEntry->getRequiredDuration() && $pendingMediaEntry->getRequiredDuration() > $entry->getLengthInMsecs()) {
             KalturaLog::info("Pending entry [" . $pendingMediaEntry->getEntryId() . "] required duration [" . $pendingMediaEntry->getRequiredDuration() . "] while entry duration [" . $entry->getLengthInMsecs() . "] is too short");
             continue;
         }
         $liveEntry->dettachPendingMediaEntry($pendingMediaEntry->getEntryId());
         $pendingEntry = entryPeer::retrieveByPK($pendingMediaEntry->getEntryId());
         if (!$pendingEntry) {
             KalturaLog::info("Pending entry [" . $pendingMediaEntry->getEntryId() . "] not found");
             continue;
         }
         $sourceAsset = assetPeer::retrieveOriginalByEntryId($entry->getId());
         if (!$sourceAsset) {
             $sourceAssets = assetPeer::retrieveReadyFlavorsByEntryId($entry->getId());
             $sourceAsset = array_pop($sourceAssets);
         }
         if (!$sourceAsset) {
             KalturaLog::info("Pending entry [" . $pendingMediaEntry->getEntryId() . "] source asset not found");
             continue;
         }
         /* @var $sourceAsset flavorAsset */
         $operationAttributes = new kClipAttributes();
         $operationAttributes->setOffset($pendingMediaEntry->getOffset());
         $operationAttributes->setDuration($pendingMediaEntry->getDuration());
         $targetAsset = assetPeer::retrieveOriginalByEntryId($pendingMediaEntry->getEntryId());
         if (!$targetAsset) {
             $targetAsset = kFlowHelper::createOriginalFlavorAsset($entry->getPartnerId(), $pendingMediaEntry->getEntryId());
         }
         $targetAsset->setFileExt($sourceAsset->getFileExt());
         $targetAsset->save();
         $sourceSyncKey = $sourceAsset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
         $targetSyncKey = $targetAsset->getSyncKey(asset::FILE_SYNC_ASSET_SUB_TYPE_ASSET);
         kFileSyncUtils::createSyncFileLinkForKey($targetSyncKey, $sourceSyncKey);
         $errDescription = '';
         kBusinessPreConvertDL::decideAddEntryFlavor(null, $pendingMediaEntry->getEntryId(), $operationAttributes->getAssetParamsId(), $errDescription, $targetAsset->getId(), array($operationAttributes));
     }
     $liveEntry->save();
 }

 protected function initFlavorAssetArray()
 {
     if (!$this->shouldInitFlavorAssetsArray()) {
         return;
     }
     $oneOnly = false;
     if ($this->deliveryAttributes->getFormat() == PlaybackProtocol::HTTP || $this->deliveryAttributes->getFormat() == "url" || $this->deliveryAttributes->getFormat() == "rtsp") {
         $oneOnly = true;
     }
     // get initial flavor list by input
     $flavorAssets = array();
     if ($this->flavorIds) {
         $flavorAssets = assetPeer::retrieveReadyByEntryId($this->entryId, $this->flavorIds);
         $flavorAssets = $this->removeNotAllowedFlavors($flavorAssets);
         $flavorAssets = $this->removeMaxBitrateFlavors($flavorAssets);
     }
     if (!$flavorAssets || !count($flavorAssets)) {
         $flavorAssets = assetPeer::retrieveReadyFlavorsByEntryId($this->entryId);
         $flavorAssets = $this->deliveryAttributes->filterFlavorsByTags($flavorAssets);
         $flavorAssets = $this->removeNotAllowedFlavors($flavorAssets);
         $flavorAssets = $this->removeMaxBitrateFlavors($flavorAssets);
     }
     if ($this->deliveryAttributes->getFormat() == PlaybackProtocol::SILVER_LIGHT) {
         $this->initSilverLightManifest($flavorAssets);
         return;
     }
     if ($this->deliveryAttributes->getFormat() == PlaybackProtocol::HDS || $this->deliveryAttributes->getFormat() == PlaybackProtocol::APPLE_HTTP) {
         // try to look for a smil manifest, if it was found, we will use it for hds and hls
         if ($this->initSmilManifest($flavorAssets)) {
             return;
         }
     }
     // get flavors availability
     $servePriority = $this->entry->getPartner()->getStorageServePriority();
     $localFlavors = array();
     $remoteFlavorsByDc = array();
     $remoteFileSyncs = array();
     foreach ($flavorAssets as $flavorAsset) {
         $flavorId = $flavorAsset->getId();
         $key = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
         $c = new Criteria();
         $c = FileSyncPeer::getCriteriaForFileSyncKey($key);
         $c->addAnd(FileSyncPeer::STATUS, FileSync::FILE_SYNC_STATUS_READY);
         switch ($servePriority) {
             case StorageProfile::STORAGE_SERVE_PRIORITY_KALTURA_ONLY:
                 $c->addAnd(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_URL, Criteria::NOT_EQUAL);
                 break;
             case StorageProfile::STORAGE_SERVE_PRIORITY_EXTERNAL_ONLY:
                 $c->add(FileSyncPeer::FILE_TYPE, FileSync::FILE_SYNC_FILE_TYPE_URL);
                 break;
         }
         if ($this->deliveryAttributes->getStorageId()) {
             $c->addAnd(FileSyncPeer::DC, $this->deliveryAttributes->getStorageId());
         }
         $fileSyncs = FileSyncPeer::doSelect($c);
         foreach ($fileSyncs as $fileSync) {
             if ($fileSync->getFileType() == FileSync::FILE_SYNC_FILE_TYPE_URL) {
                 $dc = $fileSync->getDc();
                 $remoteFlavorsByDc[$dc][$flavorId] = $flavorAsset;
                 $remoteFileSyncs[$dc][$flavorId] = $fileSync;
             } else {
                 $localFlavors[$flavorId] = $flavorAsset;
             }
         }
     }
     // filter out any invalid / disabled storage profiles
     if ($remoteFileSyncs) {
         $storageProfileIds = array_keys($remoteFileSyncs);
         $storageProfiles = StorageProfilePeer::retrieveExternalByPartnerId($this->entry->getPartnerId(), $storageProfileIds);
         $activeStorageProfileIds = array();
         foreach ($storageProfiles as $storageProfile) {
             $activeStorageProfileIds[] = $storageProfile->getId();
         }
         foreach ($storageProfileIds as $storageProfileId) {
             if (in_array($storageProfileId, $activeStorageProfileIds)) {
                 continue;
             }
             unset($remoteFlavorsByDc[$storageProfileId]);
             unset($remoteFileSyncs[$storageProfileId]);
         }
     }
     // choose the storage profile with the highest number of flavors
     $maxDc = null;
     $maxDcFlavorCount = 0;
     $remoteFlavors = array();
     foreach ($remoteFlavorsByDc as $dc => $curDcFlavors) {
         $curDcFlavorCount = count($curDcFlavors);
         if ($curDcFlavorCount <= $maxDcFlavorCount) {
             continue;
         }
         $maxDc = $dc;
         $maxDcFlavorCount = $curDcFlavorCount;
         $remoteFlavors = $curDcFlavors;
     }
     // choose the flavor set according to the serve priority
     if ($this->shouldUseLocalFlavors($localFlavors, $remoteFlavors)) {
         $this->deliveryAttributes->setStorageId(null);
         $this->deliveryAttributes->setFlavorAssets($localFlavors);
     } else {
         if ($maxDc) {
//.........这里部分代码省略.........

 /**
  * @param EntryDistribution $entryDistribution
  * @param int $action enum from DistributionAction
  * @return array<kDistributionValidationError>
  */
 public function validateForSubmission(EntryDistribution $entryDistribution, $action)
 {
     $validationErrors = array();
     $distributionProvider = $this->getProvider();
     if (!$distributionProvider) {
         KalturaLog::err("Entry distribution [" . $entryDistribution->getId() . "] provider [" . $this->getProviderType() . "] not found");
         return $validationErrors;
     }
     if ($action == DistributionAction::UPDATE || $entryDistribution->getStatus() == EntryDistributionStatus::READY || $entryDistribution->getStatus() == EntryDistributionStatus::ERROR_UPDATING) {
         if (!$distributionProvider->isUpdateEnabled() || !$distributionProvider->isMediaUpdateEnabled()) {
             KalturaLog::log("Entry distribution [" . $entryDistribution->getId() . "] provider [" . $distributionProvider->getName() . "] does not support update");
             return $validationErrors;
         }
     }
     $requiredFlavorParamsIds = $this->getRequiredFlavorParamsIdsArray();
     KalturaLog::log("Required Flavor Params Ids [" . print_r($requiredFlavorParamsIds, true) . "]");
     $entryFlavorAssets = assetPeer::retrieveReadyFlavorsByEntryId($entryDistribution->getEntryId());
     $requiredFlavorParamsIdsKeys = array_flip($requiredFlavorParamsIds);
     foreach ($entryFlavorAssets as $entryFlavorAsset) {
         $flavorParamsId = $entryFlavorAsset->getFlavorParamsId();
         if (isset($requiredFlavorParamsIdsKeys[$flavorParamsId])) {
             unset($requiredFlavorParamsIds[$requiredFlavorParamsIdsKeys[$flavorParamsId]]);
         }
     }
     foreach ($requiredFlavorParamsIds as $requiredFlavorParamsId) {
         $validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_FLAVOR, $requiredFlavorParamsId);
     }
     $requiredThumbDimensions = $this->getRequiredThumbDimensionsObjects();
     KalturaLog::log("Required Thumb Dimensions [" . print_r($requiredThumbDimensions, true) . "]");
     $entryThumbAssets = assetPeer::retrieveReadyThumbnailsByEntryId($entryDistribution->getEntryId());
     $requiredThumbDimensionsWithKeys = array();
     foreach ($requiredThumbDimensions as $requiredThumbDimension) {
         $key = $requiredThumbDimension->getKey();
         $requiredThumbDimensionsWithKeys[$key] = $requiredThumbDimension;
     }
     foreach ($entryThumbAssets as $entryThumbAsset) {
         $key = $entryThumbAsset->getWidth() . 'x' . $entryThumbAsset->getHeight();
         if (isset($requiredThumbDimensionsWithKeys[$key])) {
             unset($requiredThumbDimensionsWithKeys[$key]);
         }
     }
     foreach ($requiredThumbDimensionsWithKeys as $key => $requiredThumbDimension) {
         $validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_THUMBNAIL, $key);
     }
     $entryAssets = assetPeer::retrieveReadyByEntryId($entryDistribution->getEntryId());
     $requiredAssetDistributionRules = $this->getRequiredAssetDistributionRules();
     foreach ($requiredAssetDistributionRules as $entryAssetDistributionRule) {
         $foundMatchingAsset = false;
         /* @var $entryAssetDistributionRule kAssetDistributionRule */
         foreach ($entryAssets as $entryAsset) {
             /* @var $entryAsset asset */
             if ($entryAssetDistributionRule->fulfilled($entryAsset)) {
                 $foundMatchingAsset = true;
                 break;
             }
         }
         if (!$foundMatchingAsset) {
             $validationErrors[] = $this->createValidationError($action, DistributionErrorType::MISSING_ASSET, $entryAssetDistributionRule->getValidationError());
         }
     }
     return $validationErrors;
 }

 private function getValidVideoPath(KalturaDistributionJobData $distributionJobData)
 {
     $flavorAssets = array();
     $videoAssetFilePath = null;
     $isValidVideo = false;
     if (count($distributionJobData->entryDistribution->flavorAssetIds)) {
         $flavorAssets = assetPeer::retrieveByIds(explode(',', $distributionJobData->entryDistribution->flavorAssetIds));
     } else {
         $flavorAssets = assetPeer::retrieveReadyFlavorsByEntryId($distributionJobData->entryDistribution->entryId);
     }
     foreach ($flavorAssets as $flavorAsset) {
         $syncKey = $flavorAsset->getSyncKey(flavorAsset::FILE_SYNC_FLAVOR_ASSET_SUB_TYPE_ASSET);
         if (kFileSyncUtils::fileSync_exists($syncKey)) {
             $videoAssetFilePath = kFileSyncUtils::getLocalFilePathForKey($syncKey, false);
             $mediaInfo = mediaInfoPeer::retrieveByFlavorAssetId($flavorAsset->getId());
             if ($mediaInfo) {
                 try {
                     FacebookGraphSdkUtils::validateVideoAttributes($videoAssetFilePath, $mediaInfo->getFileSize(), $mediaInfo->getVideoDuration());
                     $isValidVideo = true;
                 } catch (Exception $e) {
                     KalturaLog::debug('Asset [' . $flavorAsset->getId() . '] not valid for distribution: ' . $e->getMessage());
                 }
             }
             if ($isValidVideo) {
                 break;
             }
         }
     }
     return $videoAssetFilePath;
 }

 private static function handleLocalFileSyncDeletion($entryId, Partner $partner)
 {
     if ($partner && $partner->getStorageDeleteFromKaltura()) {
         $readyAssets = assetPeer::retrieveReadyFlavorsByEntryId($entryId);
         self::deleteAssetLocalFileSyncsByAssetArray($readyAssets);
     }
 }

 private static function handleLocalFileSyncDeletion($entryId, Partner $partner)
 {
     if ($partner && $partner->getStorageDeleteFromKaltura()) {
         KalturaLog::debug("searching for exported assets of entry [{$entryId}] to delete local file syncs for");
         $readyAssets = assetPeer::retrieveReadyFlavorsByEntryId($entryId);
         self::deleteAssetLocalFileSyncsByAssetArray($readyAssets);
     }
 }

 /**
  * @param bool $oneOnly
  * @return array
  */
 private function buildHttpFlavorAssetArray($oneOnly)
 {
     $flavorAssets = array();
     if ($this->flavorId && ($flavorAsset = assetPeer::retrieveById($this->flavorId)) != null) {
         if ($this->assetMatchesTags($flavorAsset) && $flavorAsset->getStatus() == flavorAsset::FLAVOR_ASSET_STATUS_READY) {
             $flavorAssets[] = $flavorAsset;
         }
     } elseif ($oneOnly) {
         $webFlavorAssets = $this->getReadyFlavorsByTags();
         if (count($webFlavorAssets)) {
             $flavorAssets[] = reset($webFlavorAssets);
         }
     } else {
         if ($this->flavorIds) {
             $tmpFlavorAssets = assetPeer::retrieveReadyFlavorsByEntryId($this->entryId);
             foreach ($tmpFlavorAssets as $flavorAsset) {
                 if (in_array($flavorAsset->getId(), $this->flavorIds)) {
                     $flavorAssets[] = $flavorAsset;
                 }
             }
         } else {
             $flavorAssets = $this->getReadyFlavorsByTags();
         }
     }
     return $flavorAssets;
 }