public static function setMetadata($content, $kshow, $show_entry, $ignore_current = false, $version_info = null)
{
$xml_content = "";
$show_entry_data_key = $show_entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
$current_content = $show_entry->getMediaType() != entry::ENTRY_MEDIA_TYPE_SHOW ? "" : kFileSyncUtils::file_get_contents($show_entry_data_key);
if ($ignore_current) {
$current_content = "";
}
$update_kshow = false;
// compare the content and store only if different
if ($content != $current_content) {
$show_entry->setData("metadata.xml");
// re-create data key (to get latest version)
$show_entry_data_key = $show_entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
//$version = myContentStorage::getVersion($file_name);
//$comments = "file path: " . $file_name . "\n";
$comments = "version: " . $show_entry_data_key->version . "\n";
$total_duration = 0;
$editor_type = null;
$content = myFlvStreamer::fixMetadata($content, $show_entry_data_key->version, $total_duration, $editor_type);
// TODO - make fixMetadata a more generic funciton to return the editorType as well
// save info file about the version
if (isset($version_info)) {
$content = self::addVersionInfo($content, $version_info);
}
//fixme $content = myFlvStreamer::modifiedByKeditor ( $content );
// total_duration is in seconds with 2 digits after the decimal point
$show_entry->setLengthInMsecs($total_duration * 1000);
$show_entry->setMediaType(entry::ENTRY_MEDIA_TYPE_SHOW);
$show_entry->setEditorType($editor_type);
$show_entry->setModifiedAt(time());
// update the modified_at date
$show_entry->save();
kFileSyncUtils::file_put_contents($show_entry_data_key, $content, true);
$xml_content = kFileSyncUtils::file_get_contents($show_entry_data_key);
// replaced__getFileContent
$update_kshow = true;
$show_entry_id = $show_entry->getId();
// update the roughcut_entry table
$all_entries_for_roughcut = self::getAllEntries($content);
roughcutEntry::updateRoughcut($show_entry->getId(), $show_entry->getVersion(), $show_entry->getKshowId(), $all_entries_for_roughcut);
$xml_content = $content;
} else {
$xml_content = $current_content;
$comments = "old and new files are the same";
}
if (!$kshow->getHasRoughcut() && $kshow->getIntroId() != $show_entry->getId()) {
$kshow->setHasRoughcut(true);
$update_kshow = true;
}
myStatisticsMgr::incKshowUpdates($kshow);
$kshow->save();
return array($xml_content, $comments, $update_kshow);
}
public function fixMetadata($increment_version = true, $content = null, $total_duration = null, $specific_version = null)
{
// check that the file of the desired version really exists
$content_dir = myContentStorage::getFSContentRootPath();
if (!$content) {
$content = $this->getMetadata($specific_version);
}
if ($increment_version) {
// increment the counter of the file
$this->setData(parent::getData());
}
$file_name = kFileSyncUtils::getLocalFilePathForKey($this->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $specific_version));
// replaced__getDataPath
$duration = $total_duration ? $total_duration : myMetadataUtils::getDuration($content);
$this->setLengthInMsecs($duration * 1000);
$total_duration = null;
$editor_type = null;
$version = myContentStorage::getVersion($file_name);
$fixed_content = myFlvStreamer::fixMetadata($content, $version, $total_duration, $editor_type);
$this->save();
$sync_key = $this->getSyncKey(self::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $version);
kFileSyncUtils::file_put_contents($sync_key, $fixed_content, false);
// replaced__setFileContent
return $fixed_content;
}
public function executeImpl($partner_id, $subp_id, $puser_id, $partner_prefix, $puser_kuser)
{
if (!$partner_id) {
die;
}
$entry_id = $this->getP("entry_id");
// if the entry_type was sent by the client - make sure it's of type ENTRY_TYPE_SHOW.
// this is to prevent this service as part of a bad multirequest
$entry_type = $this->getP("entry_type", null);
if (!empty($entry_type) && $entry_type != entryType::MIX) {
$this->addDebug("entry", "not of type " . entryType::MIX);
return;
}
$kshow_id = $this->getP("kshow_id");
list($kshow, $entry, $error, $error_obj) = myKshowUtils::getKshowAndEntry($kshow_id, $entry_id);
if ($error_obj) {
$this->addError($error_obj);
return;
}
KalturaLog::log(__METHOD__ . " kshow_id [{$kshow_id}] entry_id [{$entry_id}]");
$list_type = $this->getP("list_type", self::LIST_TYPE_ROUGHCUT);
$version = $this->getP("version", null);
if ((int) $version == -1) {
$version = null;
}
// will retrieve the latest
$disable_roughcut_entry_data = $this->getP("disable_roughcut_entry_data", false);
$disable_user_data = $this->getP("disable_user_data", false);
// will allow to optimize the cals and NOT join with the kuser table
$merge_entry_lists = false;
if ($this->getPartner()) {
$merge_entry_lists = $this->getPartner()->getMergeEntryLists();
}
$kshow_entry_list = array();
$kuser_entry_list = array();
$aggrigate_id_list = array();
$this->benchmarkStart("list_type_kshow");
if ($list_type & self::LIST_TYPE_KSHOW && $kshow_id) {
$c = new Criteria();
$c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
// $c->addAnd ( entryPeer::MEDIA_TYPE , entry::ENTRY_MEDIA_TYPE_SHOW , Criteria::NOT_EQUAL );
$c->addAnd(entryPeer::KSHOW_ID, $kshow_id);
$this->addIgnoreIdList($c, $aggrigate_id_list);
// $this->addOffsetAndLimit ( $c ); // fetch as many as the kshow has
if ($disable_user_data) {
$kshow_entry_list = entryPeer::doSelect($c);
} else {
$kshow_entry_list = entryPeer::doSelectJoinkuser($c);
}
$this->updateAggrigatedIdList($aggrigate_id_list, $kshow_entry_list);
}
$this->benchmarkEnd("list_type_kshow");
$this->benchmarkStart("list_type_kuser");
if ($list_type & self::LIST_TYPE_KUSER) {
// try to get puserKuser - PS2
$puser_kuser = PuserKuserPeer::retrieveByPartnerAndUid($partner_id, null, $puser_id, false);
// try to get kuser by partnerId & puserId - PS3 - backward compatibility
$apiv3Kuser = kuserPeer::getKuserByPartnerAndUid($partner_id, $puser_id, true);
if ($puser_kuser && $puser_kuser->getKuserId() || $apiv3Kuser) {
$c = new Criteria();
$c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
// $c->addAnd ( entryPeer::MEDIA_TYPE , entry::ENTRY_MEDIA_TYPE_SHOW , Criteria::NOT_EQUAL );
$kuserIds = array();
if ($puser_kuser && $puser_kuser->getKuserId()) {
$kuserIds[] = $puser_kuser->getKuserId();
}
if ($apiv3Kuser) {
if (!$puser_kuser || $puser_kuser->getKuserId() != $apiv3Kuser->getId()) {
$kuserIds[] = $apiv3Kuser->getId();
}
}
/*
if(count($kuserIds) > 1)
{
$c->addAnd ( entryPeer::KUSER_ID , $kuserIds, Criteria::IN );
}
else
{
$c->addAnd ( entryPeer::KUSER_ID , $kuserIds[0] );
}
if ( $merge_entry_lists )
{
// if will join lists - no need to fetch entries twice
$this->addIgnoreIdList ($c , $aggrigate_id_list);
}
$this->addOffsetAndLimit ( $c ); // limit the number of the user's clips
if ( $disable_user_data )
$kuser_entry_list = entryPeer::doSelect( $c );
else
$kuser_entry_list = entryPeer::doSelectJoinkuser( $c );
*/
$this->addOffsetAndLimit($c);
// limit the number of the user's clips
if ($merge_entry_lists) {
// if will join lists - no need to fetch entries twice
$this->addIgnoreIdList($c, $aggrigate_id_list);
}
$kuser_entry_list = array();
$kuserIds = array_unique($kuserIds);
foreach ($kuserIds as $kuserId) {
$newC = clone $c;
$newC->addAnd(entryPeer::KUSER_ID, $kuserId);
if ($disable_user_data) {
$one_kuser_list = entryPeer::doSelect($newC);
} else {
$one_kuser_list = entryPeer::doSelectJoinkuser($newC);
}
$kuser_entry_list = array_merge($kuser_entry_list, $one_kuser_list);
}
// Since we are using 2 potential kusers, we might not have the obvious kuser from $puser_kuser
$strEntries = "";
if ($puser_kuser) {
$kuser = kuserPeer::retrieveByPk($puser_kuser->getKuserId());
if ($kuser) {
$strEntriesTemp = @unserialize($kuser->getPartnerData());
if ($strEntriesTemp) {
$strEntries .= $strEntriesTemp;
}
}
}
if ($apiv3Kuser) {
$strEntriesTemp = @unserialize($apiv3Kuser->getPartnerData());
if ($strEntriesTemp) {
$strEntries .= $strEntriesTemp;
}
}
if ($strEntries) {
$entries = explode(',', $strEntries);
$fixed_entry_list = array();
foreach ($entries as $entryId) {
$fixed_entry_list[] = trim($entryId);
}
$c = new Criteria();
$c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
$c->addAnd(entryPeer::ID, $fixed_entry_list, Criteria::IN);
if ($merge_entry_lists) {
// if will join lists - no need to fetch entries twice
$this->addIgnoreIdList($c, $aggrigate_id_list);
}
if ($disable_user_data) {
$extra_user_entries = entryPeer::doSelect($c);
} else {
$extra_user_entries = entryPeer::doSelectJoinkuser($c);
}
if (count($extra_user_entries)) {
$kuser_entry_list = array_merge($extra_user_entries, $kuser_entry_list);
}
}
} else {
$kuser_entry_list = array();
}
if ($merge_entry_lists) {
$kshow_entry_list = kArray::append($kshow_entry_list, $kuser_entry_list);
$kuser_entry_list = null;
}
}
$this->benchmarkEnd("list_type_kuser");
$this->benchmarkStart("list_type_episode");
if ($list_type & self::LIST_TYPE_EPISODE) {
if ($kshow && $kshow->getEpisodeId()) {
// episode_id will point to the "parent" kshow
// fetch the entries of the parent kshow
$c = new Criteria();
$c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
// $c->addAnd ( entryPeer::MEDIA_TYPE , entry::ENTRY_MEDIA_TYPE_SHOW , Criteria::NOT_EQUAL );
$c->addAnd(entryPeer::KSHOW_ID, $kshow->getEpisodeId());
$this->addIgnoreIdList($c, $aggrigate_id_list);
// $this->addOffsetAndLimit ( $c ); // limit the number of the inherited entries from the episode
if ($disable_user_data) {
$parent_kshow_entries = entryPeer::doSelect($c);
} else {
$parent_kshow_entries = entryPeer::doSelectJoinkuser($c);
}
if (count($parent_kshow_entries)) {
$kshow_entry_list = kArray::append($kshow_entry_list, $parent_kshow_entries);
}
}
}
$this->benchmarkEnd("list_type_episode");
// fetch all entries that were used in the roughcut - those of other kusers
// - appeared under kuser_entry_list when someone else logged in
$this->benchmarkStart("list_type_roughcut");
$entry_data_from_roughcut_map = array();
// will hold an associative array where the id is the key
if ($list_type & self::LIST_TYPE_ROUGHCUT) {
if ($entry->getType() == entryType::MIX) {
$sync_key = $entry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA, $version);
$roughcut_file_name = kFileSyncUtils::getReadyLocalFilePathForKey($sync_key);
$entry_data_from_roughcut = myFlvStreamer::getAllAssetsData($roughcut_file_name);
$final_id_list = array();
foreach ($entry_data_from_roughcut as $data) {
$id = $data["id"];
// first element is the id
$entry_data_from_roughcut_map[] = $data;
$found = false;
foreach ($kshow_entry_list as $entry) {
// see we are not fetching duplicate entries
if ($entry->getId() == $id) {
$found = true;
break;
}
}
if (!$found) {
$final_id_list[] = $id;
}
}
if (count($final_id_list) > 0) {
// allow deleted entries when searching for entries on the roughcut
// don't forget to return the status at the end of the process
entryPeer::allowDeletedInCriteriaFilter();
$c = new Criteria();
$c->addAnd(entryPeer::ID, $final_id_list, Criteria::IN);
$c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
$this->addIgnoreIdList($c, $aggrigate_id_list);
// $this->addOffsetAndLimit ( $c );
if ($disable_user_data) {
$extra_entries = entryPeer::doSelect($c);
} else {
$extra_entries = entryPeer::doSelectJoinkuser($c);
}
// return the status to the criteriaFilter
entryPeer::blockDeletedInCriteriaFilter();
// merge the 2 lists into 1:
$kshow_entry_list = kArray::append($kshow_entry_list, $extra_entries);
}
}
}
$this->benchmarkEnd("list_type_roughcut");
$this->benchmarkStart("create_wrapper");
$entry_wrapper = objectWrapperBase::getWrapperClass($kshow_entry_list, objectWrapperBase::DETAIL_LEVEL_REGULAR, -3, 0, array("contributorScreenName"));
//$entry_wrapper->addFields ( array ( "kuser.screenName" ) );
$this->addMsg("show", $entry_wrapper);
// if ! $disable_roughcut_entry_data - add the roughcut_entry_data
if (!$disable_roughcut_entry_data) {
$this->addMsg("roughcut_entry_data", $entry_data_from_roughcut_map);
}
if (count($kuser_entry_list) > 0) {
$this->addMsg("user", objectWrapperBase::getWrapperClass($kuser_entry_list, objectWrapperBase::DETAIL_LEVEL_REGULAR));
} else {
$this->addMsg("user", null);
}
$this->benchmarkEnd("create_wrapper");
}
protected function executeImpl(kshow $kshow, entry &$entry)
{
$list_type = $this->getP("list_type", self::LIST_TYPE_ALL);
$kshow_entry_list = array();
$kuser_entry_list = array();
if ($list_type & self::LIST_TYPE_KSHOW) {
$c = new Criteria();
$c->add(entryPeer::TYPE, entryType::MEDIA_CLIP);
$c->add(entryPeer::MEDIA_TYPE, entry::ENTRY_MEDIA_TYPE_SHOW, Criteria::NOT_EQUAL);
$c->add(entryPeer::KSHOW_ID, $this->kshow_id);
$kshow_entry_list = entryPeer::doSelectJoinkuser($c);
}
if ($list_type & self::LIST_TYPE_KUSER) {
$c = new Criteria();
$c->add(entryPeer::TYPE, entryType::MEDIA_CLIP);
$c->add(entryPeer::MEDIA_TYPE, entry::ENTRY_MEDIA_TYPE_SHOW, Criteria::NOT_EQUAL);
$c->add(entryPeer::KUSER_ID, $this->getLoggedInUserIds(), Criteria::IN);
$kuser_entry_list = entryPeer::doSelectJoinkuser($c);
}
if ($list_type & self::LIST_TYPE_EPISODE) {
if ($kshow->getEpisodeId()) {
// episode_id will point to the "parent" kshow
// fetch the entries of the parent kshow
$c = new Criteria();
$c->add(entryPeer::TYPE, entryType::MEDIA_CLIP);
$c->add(entryPeer::MEDIA_TYPE, entry::ENTRY_MEDIA_TYPE_SHOW, Criteria::NOT_EQUAL);
$c->add(entryPeer::KSHOW_ID, $kshow->getEpisodeId());
$parent_kshow_entries = entryPeer::doSelectJoinkuser($c);
if (count($parent_kshow_entries)) {
$kshow_entry_list = kArray::append($kshow_entry_list, $parent_kshow_entries);
}
}
}
// fetch all entries that were used in the roughcut - those of other kusers
// - appeared under kuser_entry_list when someone else logged in
if ($list_type & self::LIST_TYPE_ROUGHCUT) {
if ($kshow->getHasRoughcut()) {
$roughcut_file_name = $entry->getDataPath();
$entry_ids_from_roughcut = myFlvStreamer::getAllAssetsIds($roughcut_file_name);
$final_id_list = array();
foreach ($entry_ids_from_roughcut as $id) {
$found = false;
foreach ($kshow_entry_list as $entry) {
if ($entry->getId() == $id) {
$found = true;
break;
}
}
if (!$found) {
$final_id_list[] = $id;
}
}
$c = new Criteria();
$c->add(entryPeer::ID, $final_id_list, Criteria::IN);
$extra_entries = entryPeer::doSelectJoinkuser($c);
// merge the 2 lists into 1:
$kshow_entry_list = kArray::append($kshow_entry_list, $extra_entries);
}
}
$this->kshow_entry_list = $kshow_entry_list;
$this->kuser_entry_list = $kuser_entry_list;
}
/**
* Get all ready media entries that exist in the given mix id
*
* @action getReadyMediaEntries
* @param string $mixId
* @param int $version Desired version to get the data from
* @return KalturaMediaEntryArray
*/
public function getReadyMediaEntriesAction($mixId, $version = -1)
{
$dbEntry = entryPeer::retrieveByPK($mixId);
if (!$dbEntry || $dbEntry->getType() != KalturaEntryType::MIX) {
throw new KalturaAPIException(KalturaErrors::ENTRY_ID_NOT_FOUND, $mixId);
}
$dataSyncKey = $dbEntry->getSyncKey(entry::FILE_SYNC_ENTRY_SUB_TYPE_DATA);
$mixFileName = kFileSyncUtils::getReadyLocalFilePathForKey($dataSyncKey, false);
if (!$mixFileName) {
KExternalErrors::dieError(KExternalErrors::FILE_NOT_FOUND);
}
$entryDataFromMix = myFlvStreamer::getAllAssetsData($mixFileName);
$ids = array();
foreach ($entryDataFromMix as $data) {
$ids[] = $data["id"];
}
$c = KalturaCriteria::create(entryPeer::OM_CLASS);
$c->addAnd(entryPeer::ID, $ids, Criteria::IN);
$c->addAnd(entryPeer::TYPE, entryType::MEDIA_CLIP);
$dbEntries = entryPeer::doSelect($c);
$mediaEntries = KalturaMediaEntryArray::fromEntryArray($dbEntries);
return $mediaEntries;
}
