920 lines
29 KiB
PHP
920 lines
29 KiB
PHP
<?php
|
|
|
|
class Application_Model_Preference
|
|
{
|
|
|
|
public static function SetValue($key, $value, $isUserValue = false){
|
|
try {
|
|
$con = Propel::getConnection();
|
|
|
|
//called from a daemon process
|
|
if(!class_exists("Zend_Auth", false) || !Zend_Auth::getInstance()->hasIdentity()) {
|
|
$id = NULL;
|
|
}
|
|
else {
|
|
$auth = Zend_Auth::getInstance();
|
|
$id = $auth->getIdentity()->id;
|
|
}
|
|
|
|
$key = pg_escape_string($key);
|
|
$value = pg_escape_string($value);
|
|
|
|
//Check if key already exists
|
|
$sql = "SELECT COUNT(*) FROM cc_pref"
|
|
." WHERE keystr = '$key'";
|
|
|
|
//For user specific preference, check if id matches as well
|
|
if($isUserValue) {
|
|
$sql .= " AND subjid = '$id'";
|
|
}
|
|
|
|
$result = $con->query($sql)->fetchColumn(0);
|
|
|
|
if($value == "") {
|
|
$value = "NULL";
|
|
}else {
|
|
$value = "'$value'";
|
|
}
|
|
|
|
if($result == 1) {
|
|
// result found
|
|
if(is_null($id) || !$isUserValue) {
|
|
// system pref
|
|
$sql = "UPDATE cc_pref"
|
|
." SET subjid = NULL, valstr = $value"
|
|
." WHERE keystr = '$key'";
|
|
} else {
|
|
// user pref
|
|
$sql = "UPDATE cc_pref"
|
|
. " SET valstr = $value"
|
|
. " WHERE keystr = '$key' AND subjid = $id";
|
|
}
|
|
} else {
|
|
// result not found
|
|
if(is_null($id) || !$isUserValue) {
|
|
// system pref
|
|
$sql = "INSERT INTO cc_pref (keystr, valstr)"
|
|
." VALUES ('$key', $value)";
|
|
} else {
|
|
// user pref
|
|
$sql = "INSERT INTO cc_pref (subjid, keystr, valstr)"
|
|
." VALUES ($id, '$key', $value)";
|
|
}
|
|
}
|
|
|
|
$con->exec($sql);
|
|
|
|
} catch (Exception $e){
|
|
header('HTTP/1.0 503 Service Unavailable');
|
|
Logging::log("Could not connect to database: ".$e->getMessage());
|
|
exit;
|
|
}
|
|
|
|
}
|
|
|
|
public static function GetValue($key, $isUserValue = false){
|
|
try {
|
|
$con = Propel::getConnection();
|
|
|
|
//Check if key already exists
|
|
$sql = "SELECT COUNT(*) FROM cc_pref"
|
|
." WHERE keystr = '$key'";
|
|
//For user specific preference, check if id matches as well
|
|
if ($isUserValue) {
|
|
$auth = Zend_Auth::getInstance();
|
|
if($auth->hasIdentity()) {
|
|
$id = $auth->getIdentity()->id;
|
|
$sql .= " AND subjid = '$id'";
|
|
}
|
|
}
|
|
$result = $con->query($sql)->fetchColumn(0);
|
|
if ($result == 0)
|
|
return "";
|
|
else {
|
|
$sql = "SELECT valstr FROM cc_pref"
|
|
." WHERE keystr = '$key'";
|
|
|
|
//For user specific preference, check if id matches as well
|
|
if($isUserValue && $auth->hasIdentity()) {
|
|
$sql .= " AND subjid = '$id'";
|
|
}
|
|
|
|
$result = $con->query($sql)->fetchColumn(0);
|
|
return ($result !== false) ? $result : "";
|
|
}
|
|
} catch (Exception $e) {
|
|
header('HTTP/1.0 503 Service Unavailable');
|
|
Logging::log("Could not connect to database: ".$e->getMessage());
|
|
exit;
|
|
}
|
|
}
|
|
|
|
public static function GetHeadTitle(){
|
|
$title = self::GetValue("station_name");
|
|
$defaultNamespace->title = $title;
|
|
if (strlen($title) > 0)
|
|
$title .= " - ";
|
|
|
|
return $title."Airtime";
|
|
}
|
|
|
|
public static function SetHeadTitle($title, $view=null){
|
|
self::SetValue("station_name", $title);
|
|
|
|
// in case this is called from airtime-saas script
|
|
if($view !== null){
|
|
//set session variable to new station name so that html title is updated.
|
|
//should probably do this in a view helper to keep this controller as minimal as possible.
|
|
$view->headTitle()->exchangeArray(array()); //clear headTitle ArrayObject
|
|
$view->headTitle(self::GetHeadTitle());
|
|
}
|
|
|
|
$eventType = "update_station_name";
|
|
$md = array("station_name"=>$title);
|
|
|
|
Application_Model_RabbitMq::SendMessageToPypo($eventType, $md);
|
|
}
|
|
|
|
/**
|
|
* Set the furthest date that a never-ending show
|
|
* should be populated until.
|
|
*
|
|
* @param DateTime $dateTime
|
|
* A row from cc_show_days table
|
|
*/
|
|
public static function SetShowsPopulatedUntil($dateTime) {
|
|
self::SetValue("shows_populated_until", $dateTime->format("Y-m-d H:i:s"));
|
|
}
|
|
|
|
/**
|
|
* Get the furthest date that a never-ending show
|
|
* should be populated until.
|
|
*
|
|
* Returns null if the value hasn't been set, otherwise returns
|
|
* a DateTime object representing the date.
|
|
*
|
|
* @return DateTime (in UTC Timezone)
|
|
*/
|
|
public static function GetShowsPopulatedUntil() {
|
|
$date = self::GetValue("shows_populated_until");
|
|
|
|
if ($date == ""){
|
|
return null;
|
|
} else {
|
|
return new DateTime($date, new DateTimeZone("UTC"));
|
|
}
|
|
}
|
|
|
|
public static function SetDefaultFade($fade) {
|
|
self::SetValue("default_fade", $fade);
|
|
}
|
|
|
|
public static function GetDefaultFade() {
|
|
$fade = self::GetValue("default_fade");
|
|
|
|
if ($fade === "") {
|
|
// the default value of the fade is 00.500000
|
|
return "00.500000";
|
|
}
|
|
|
|
// we need this function to work with 2.0 version on default_fade value in cc_pref
|
|
// it has 00:00:00.000000 format where in 2.1 we have 00.000000 format
|
|
if(preg_match("/([0-9]{2}):([0-9]{2}):([0-9]{2}).([0-9]{6})/", $fade, $matches) == 1 && count($matches) == 5){
|
|
$out = 0;
|
|
$out += intval($matches[1] * 3600);
|
|
$out += intval($matches[2] * 60);
|
|
$out += intval($matches[3]);
|
|
$out .= ".$matches[4]";
|
|
$fade = $out;
|
|
}
|
|
|
|
$fade = number_format($fade, 6);
|
|
//fades need 2 leading zeros for DateTime conversion
|
|
$fade = str_pad($fade, 9, "0", STR_PAD_LEFT);
|
|
return $fade;
|
|
}
|
|
|
|
public static function SetDefaultTransitionFade($fade) {
|
|
self::SetValue("default_transition_fade", $fade);
|
|
|
|
$eventType = "update_transition_fade";
|
|
$md = array("transition_fade"=>$fade);
|
|
Application_Model_RabbitMq::SendMessageToPypo($eventType, $md);
|
|
}
|
|
|
|
public static function GetDefaultTransitionFade() {
|
|
$transition_fade = self::GetValue("default_transition_fade");
|
|
if($transition_fade == ""){
|
|
$transition_fade = "00.000000";
|
|
}
|
|
return $transition_fade;
|
|
}
|
|
|
|
public static function SetStreamLabelFormat($type){
|
|
self::SetValue("stream_label_format", $type);
|
|
|
|
$eventType = "update_stream_format";
|
|
$md = array("stream_format"=>$type);
|
|
|
|
Application_Model_RabbitMq::SendMessageToPypo($eventType, $md);
|
|
}
|
|
|
|
public static function GetStreamLabelFormat(){
|
|
return self::getValue("stream_label_format");
|
|
}
|
|
|
|
public static function GetStationName(){
|
|
return self::getValue("station_name");
|
|
}
|
|
|
|
public static function SetAutoUploadRecordedShowToSoundcloud($upload) {
|
|
self::SetValue("soundcloud_auto_upload_recorded_show", $upload);
|
|
}
|
|
|
|
public static function GetAutoUploadRecordedShowToSoundcloud() {
|
|
return self::GetValue("soundcloud_auto_upload_recorded_show");
|
|
}
|
|
|
|
public static function SetSoundCloudUser($user) {
|
|
self::SetValue("soundcloud_user", $user);
|
|
}
|
|
|
|
public static function GetSoundCloudUser() {
|
|
return self::GetValue("soundcloud_user");
|
|
}
|
|
|
|
public static function SetSoundCloudPassword($password) {
|
|
if (strlen($password) > 0)
|
|
self::SetValue("soundcloud_password", $password);
|
|
}
|
|
|
|
public static function GetSoundCloudPassword() {
|
|
return self::GetValue("soundcloud_password");
|
|
}
|
|
|
|
public static function SetSoundCloudTags($tags) {
|
|
self::SetValue("soundcloud_tags", $tags);
|
|
}
|
|
|
|
public static function GetSoundCloudTags() {
|
|
return self::GetValue("soundcloud_tags");
|
|
}
|
|
|
|
public static function SetSoundCloudGenre($genre) {
|
|
self::SetValue("soundcloud_genre", $genre);
|
|
}
|
|
|
|
public static function GetSoundCloudGenre() {
|
|
return self::GetValue("soundcloud_genre");
|
|
}
|
|
|
|
public static function SetSoundCloudTrackType($track_type) {
|
|
self::SetValue("soundcloud_tracktype", $track_type);
|
|
}
|
|
|
|
public static function GetSoundCloudTrackType() {
|
|
return self::GetValue("soundcloud_tracktype");
|
|
}
|
|
|
|
public static function SetSoundCloudLicense($license) {
|
|
self::SetValue("soundcloud_license", $license);
|
|
}
|
|
|
|
public static function GetSoundCloudLicense() {
|
|
return self::GetValue("soundcloud_license");
|
|
}
|
|
|
|
public static function SetAllow3rdPartyApi($bool) {
|
|
self::SetValue("third_party_api", $bool);
|
|
}
|
|
|
|
public static function GetAllow3rdPartyApi() {
|
|
$val = self::GetValue("third_party_api");
|
|
if (strlen($val) == 0){
|
|
return "0";
|
|
} else {
|
|
return $val;
|
|
}
|
|
}
|
|
|
|
public static function SetPhone($phone){
|
|
self::SetValue("phone", $phone);
|
|
}
|
|
|
|
public static function GetPhone(){
|
|
return self::GetValue("phone");
|
|
}
|
|
|
|
public static function SetEmail($email){
|
|
self::SetValue("email", $email);
|
|
}
|
|
|
|
public static function GetEmail(){
|
|
return self::GetValue("email");
|
|
}
|
|
|
|
public static function SetStationWebSite($site){
|
|
self::SetValue("station_website", $site);
|
|
}
|
|
|
|
public static function GetStationWebSite(){
|
|
return self::GetValue("station_website");
|
|
}
|
|
|
|
public static function SetSupportFeedback($feedback){
|
|
self::SetValue("support_feedback", $feedback);
|
|
}
|
|
|
|
public static function GetSupportFeedback(){
|
|
return self::GetValue("support_feedback");
|
|
}
|
|
|
|
public static function SetPublicise($publicise){
|
|
self::SetValue("publicise", $publicise);
|
|
}
|
|
|
|
public static function GetPublicise(){
|
|
return self::GetValue("publicise");
|
|
}
|
|
|
|
public static function SetRegistered($registered){
|
|
self::SetValue("registered", $registered);
|
|
}
|
|
|
|
public static function GetRegistered(){
|
|
return self::GetValue("registered");
|
|
}
|
|
|
|
public static function SetStationCountry($country){
|
|
self::SetValue("country", $country);
|
|
}
|
|
|
|
public static function GetStationCountry(){
|
|
return self::GetValue("country");
|
|
}
|
|
|
|
public static function SetStationCity($city){
|
|
self::SetValue("city", $city);
|
|
}
|
|
|
|
public static function GetStationCity(){
|
|
return self::GetValue("city");
|
|
}
|
|
|
|
public static function SetStationDescription($description){
|
|
self::SetValue("description", $description);
|
|
}
|
|
|
|
public static function GetStationDescription(){
|
|
return self::GetValue("description");
|
|
}
|
|
|
|
public static function SetTimezone($timezone){
|
|
self::SetValue("timezone", $timezone);
|
|
date_default_timezone_set($timezone);
|
|
$md = array("timezone" => $timezone);
|
|
}
|
|
|
|
public static function GetTimezone(){
|
|
return self::GetValue("timezone");
|
|
}
|
|
|
|
public static function SetStationLogo($imagePath){
|
|
if(!empty($imagePath)){
|
|
$image = @file_get_contents($imagePath);
|
|
$image = base64_encode($image);
|
|
self::SetValue("logoImage", $image);
|
|
}
|
|
}
|
|
|
|
public static function GetStationLogo(){
|
|
return self::GetValue("logoImage");
|
|
}
|
|
|
|
public static function GetUniqueId(){
|
|
return self::GetValue("uniqueId");
|
|
}
|
|
|
|
public static function GetCountryList()
|
|
{
|
|
$con = Propel::getConnection();
|
|
$sql = "SELECT * FROM cc_country";
|
|
$res = $con->query($sql)->fetchAll();
|
|
$out = array();
|
|
$out[""] = "Select Country";
|
|
foreach($res as $r){
|
|
$out[$r["isocode"]] = $r["name"];
|
|
}
|
|
return $out;
|
|
}
|
|
|
|
public static function GetSystemInfo($returnArray=false, $p_testing=false)
|
|
{
|
|
exec('/usr/bin/airtime-check-system --no-color', $output);
|
|
$output = preg_replace('/\s+/', ' ', $output);
|
|
|
|
$systemInfoArray = array();
|
|
foreach( $output as $key => &$out){
|
|
$info = explode('=', $out);
|
|
if(isset($info[1])){
|
|
$key = str_replace(' ', '_', trim($info[0]));
|
|
$key = strtoupper($key);
|
|
if ($key == 'WEB_SERVER' || $key == 'CPU' || $key == 'OS' || $key == 'TOTAL_RAM' ||
|
|
$key == 'FREE_RAM' || $key == 'AIRTIME_VERSION' || $key == 'KERNAL_VERSION' ||
|
|
$key == 'MACHINE_ARCHITECTURE' || $key == 'TOTAL_MEMORY_MBYTES' || $key == 'TOTAL_SWAP_MBYTES' ||
|
|
$key == 'PLAYOUT_ENGINE_CPU_PERC' ) {
|
|
if($key == 'AIRTIME_VERSION'){
|
|
// remove hash tag on the version string
|
|
$version = explode('+', $info[1]);
|
|
$systemInfoArray[$key] = $version[0];
|
|
}else{
|
|
$systemInfoArray[$key] = $info[1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$outputArray = array();
|
|
|
|
$outputArray['LIVE_DURATION'] = Application_Model_LiveLog::GetLiveShowDuration($p_testing);
|
|
$outputArray['SCHEDULED_DURATION'] = Application_Model_LiveLog::GetScheduledDuration($p_testing);
|
|
$outputArray['SOUNDCLOUD_ENABLED'] = self::GetUploadToSoundcloudOption();
|
|
if ($outputArray['SOUNDCLOUD_ENABLED']) {
|
|
$outputArray['NUM_SOUNDCLOUD_TRACKS_UPLOADED'] = Application_Model_StoredFile::getSoundCloudUploads();
|
|
} else {
|
|
$outputArray['NUM_SOUNDCLOUD_TRACKS_UPLOADED'] = NULL;
|
|
}
|
|
$outputArray['STATION_NAME'] = self::GetStationName();
|
|
$outputArray['PHONE'] = self::GetPhone();
|
|
$outputArray['EMAIL'] = self::GetEmail();
|
|
$outputArray['STATION_WEB_SITE'] = self::GetStationWebSite();
|
|
$outputArray['STATION_COUNTRY'] = self::GetStationCountry();
|
|
$outputArray['STATION_CITY'] = self::GetStationCity();
|
|
$outputArray['STATION_DESCRIPTION'] = self::GetStationDescription();
|
|
|
|
// get web server info
|
|
if(isset($systemInfoArray["AIRTIME_VERSION_URL"])){
|
|
$url = $systemInfoArray["AIRTIME_VERSION_URL"];
|
|
$index = strpos($url,'/api/');
|
|
$url = substr($url, 0, $index);
|
|
|
|
$headerInfo = get_headers(trim($url),1);
|
|
$outputArray['WEB_SERVER'] = $headerInfo['Server'][0];
|
|
}
|
|
|
|
$outputArray['NUM_OF_USERS'] = Application_Model_User::getUserCount();
|
|
$outputArray['NUM_OF_SONGS'] = Application_Model_StoredFile::getFileCount();
|
|
$outputArray['NUM_OF_PLAYLISTS'] = Application_Model_Playlist::getPlaylistCount();
|
|
$outputArray['NUM_OF_SCHEDULED_PLAYLISTS'] = Application_Model_Schedule::getSchduledPlaylistCount();
|
|
$outputArray['NUM_OF_PAST_SHOWS'] = Application_Model_ShowInstance::GetShowInstanceCount(gmdate("Y-m-d H:i:s"));
|
|
$outputArray['UNIQUE_ID'] = self::GetUniqueId();
|
|
$outputArray['SAAS'] = self::GetPlanLevel();
|
|
if ($outputArray['SAAS'] != 'disabled') {
|
|
$outputArray['TRIAL_END_DATE'] = self::GetTrialEndingDate();
|
|
} else {
|
|
$outputArray['TRIAL_END_DATE'] = NULL;
|
|
}
|
|
$outputArray['INSTALL_METHOD'] = self::GetInstallMethod();
|
|
$outputArray['NUM_OF_STREAMS'] = self::GetNumOfStreams();
|
|
$outputArray['STREAM_INFO'] = Application_Model_StreamSetting::getStreamInfoForDataCollection();
|
|
|
|
$outputArray = array_merge($systemInfoArray, $outputArray);
|
|
|
|
$outputString = "\n";
|
|
foreach($outputArray as $key => $out){
|
|
if($key == 'TRIAL_END_DATE' && ($out != '' || $out != 'NULL')){
|
|
continue;
|
|
}
|
|
if($key == "STREAM_INFO"){
|
|
$outputString .= $key." :\n";
|
|
foreach($out as $s_info){
|
|
foreach($s_info as $k => $v){
|
|
$outputString .= "\t".strtoupper($k)." : ".$v."\n";
|
|
}
|
|
}
|
|
}else if ($key == "SOUNDCLOUD_ENABLED") {
|
|
if ($out) {
|
|
$outputString .= $key." : TRUE\n";
|
|
} else if (!$out) {
|
|
$outputString .= $key." : FALSE\n";
|
|
}
|
|
}else if ($key == "SAAS") {
|
|
if (strcmp($out, 'disabled')!=0) {
|
|
$outputString .= $key.' : '.$out."\n";
|
|
}
|
|
}else{
|
|
$outputString .= $key.' : '.$out."\n";
|
|
}
|
|
}
|
|
if($returnArray){
|
|
$outputArray['PROMOTE'] = self::GetPublicise();
|
|
$outputArray['LOGOIMG'] = self::GetStationLogo();
|
|
return $outputArray;
|
|
}else{
|
|
return $outputString;
|
|
}
|
|
}
|
|
|
|
public static function GetInstallMethod(){
|
|
$easy_install = file_exists('/usr/bin/airtime-easy-setup');
|
|
$debian_install = file_exists('/var/lib/dpkg/info/airtime.config');
|
|
if($debian_install){
|
|
if($easy_install){
|
|
return "easy_install";
|
|
}else{
|
|
return "debian_install";
|
|
}
|
|
}else{
|
|
return "manual_install";
|
|
}
|
|
}
|
|
|
|
public static function SetRemindMeDate(){
|
|
$weekAfter = mktime(0, 0, 0, gmdate("m"), gmdate("d")+7, gmdate("Y"));
|
|
self::SetValue("remindme", $weekAfter);
|
|
}
|
|
|
|
public static function GetRemindMeDate(){
|
|
return self::GetValue("remindme");
|
|
}
|
|
|
|
public static function SetImportTimestamp(){
|
|
$now = time();
|
|
if(self::GetImportTimestamp()+5 < $now){
|
|
self::SetValue("import_timestamp", $now);
|
|
}
|
|
}
|
|
|
|
public static function GetImportTimestamp(){
|
|
return self::GetValue("import_timestamp");
|
|
}
|
|
|
|
public static function GetStreamType(){
|
|
$st = self::GetValue("stream_type");
|
|
return explode(',', $st);
|
|
}
|
|
|
|
public static function GetStreamBitrate(){
|
|
$sb = self::GetValue("stream_bitrate");
|
|
return explode(',', $sb);
|
|
}
|
|
|
|
public static function SetPrivacyPolicyCheck($flag){
|
|
self::SetValue("privacy_policy", $flag);
|
|
}
|
|
|
|
public static function GetPrivacyPolicyCheck(){
|
|
return self::GetValue("privacy_policy");
|
|
}
|
|
|
|
public static function SetNumOfStreams($num){
|
|
self::SetValue("num_of_streams", intval($num));
|
|
}
|
|
|
|
public static function GetNumOfStreams(){
|
|
return self::GetValue("num_of_streams");
|
|
}
|
|
|
|
public static function SetMaxBitrate($bitrate){
|
|
self::SetValue("max_bitrate", intval($bitrate));
|
|
}
|
|
|
|
public static function GetMaxBitrate(){
|
|
return self::GetValue("max_bitrate");
|
|
}
|
|
|
|
public static function SetPlanLevel($plan){
|
|
self::SetValue("plan_level", $plan);
|
|
}
|
|
|
|
public static function GetPlanLevel(){
|
|
$plan = self::GetValue("plan_level");
|
|
if(trim($plan) == ''){
|
|
$plan = 'disabled';
|
|
}
|
|
return $plan;
|
|
}
|
|
|
|
public static function SetTrialEndingDate($date){
|
|
self::SetValue("trial_end_date", $date);
|
|
}
|
|
|
|
public static function GetTrialEndingDate(){
|
|
return self::GetValue("trial_end_date");
|
|
}
|
|
|
|
public static function SetEnableStreamConf($bool){
|
|
self::SetValue("enable_stream_conf", $bool);
|
|
}
|
|
|
|
public static function GetEnableStreamConf(){
|
|
if(self::GetValue("enable_stream_conf") == Null){
|
|
return "true";
|
|
}
|
|
return self::GetValue("enable_stream_conf");
|
|
}
|
|
|
|
public static function GetAirtimeVersion(){
|
|
if (defined('APPLICATION_ENV') && APPLICATION_ENV == "development" && function_exists('exec')){
|
|
$version = exec("git rev-parse --short HEAD 2>/dev/null", $out, $return_code);
|
|
if ($return_code == 0){
|
|
return self::GetValue("system_version")."+".$version.":".time();
|
|
}
|
|
}
|
|
return self::GetValue("system_version");
|
|
}
|
|
|
|
public static function GetLatestVersion(){
|
|
$latest = self::GetValue("latest_version");
|
|
if($latest == null || strlen($latest) == 0) {
|
|
return self::GetAirtimeVersion();
|
|
} else {
|
|
return $latest;
|
|
}
|
|
}
|
|
|
|
public static function SetLatestVersion($version){
|
|
$pattern = "/^[0-9]+\.[0-9]+\.[0-9]+/";
|
|
if(preg_match($pattern, $version)) {
|
|
self::SetValue("latest_version", $version);
|
|
}
|
|
}
|
|
|
|
public static function GetLatestLink(){
|
|
$link = self::GetValue("latest_link");
|
|
if($link == null || strlen($link) == 0) {
|
|
return 'http://airtime.sourcefabric.org';
|
|
} else {
|
|
return $link;
|
|
}
|
|
}
|
|
|
|
public static function SetLatestLink($link){
|
|
$pattern = "#^(http|https|ftp)://" .
|
|
"([a-zA-Z0-9]+\.)*[a-zA-Z0-9]+" .
|
|
"(/[a-zA-Z0-9\-\.\_\~\:\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=]+)*/?$#";
|
|
if(preg_match($pattern, $link)) {
|
|
self::SetValue("latest_link", $link);
|
|
}
|
|
}
|
|
|
|
public static function SetUploadToSoundcloudOption($upload) {
|
|
self::SetValue("soundcloud_upload_option", $upload);
|
|
}
|
|
|
|
public static function GetUploadToSoundcloudOption() {
|
|
return self::GetValue("soundcloud_upload_option");
|
|
}
|
|
|
|
public static function SetSoundCloudDownloadbleOption($upload) {
|
|
self::SetValue("soundcloud_downloadable", $upload);
|
|
}
|
|
|
|
public static function GetSoundCloudDownloadbleOption() {
|
|
return self::GetValue("soundcloud_downloadable");
|
|
}
|
|
|
|
public static function SetWeekStartDay($day) {
|
|
self::SetValue("week_start_day", $day);
|
|
}
|
|
|
|
public static function GetWeekStartDay() {
|
|
$val = self::GetValue("week_start_day");
|
|
if (strlen($val) == 0){
|
|
return "0";
|
|
} else {
|
|
return $val;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stores the last timestamp of user updating stream setting
|
|
*/
|
|
public static function SetStreamUpdateTimestamp() {
|
|
$now = time();
|
|
self::SetValue("stream_update_timestamp", $now);
|
|
}
|
|
|
|
/**
|
|
* Gets the last timestamp of user updating stream setting
|
|
*/
|
|
public static function GetStreamUpdateTimestemp() {
|
|
$update_time = self::GetValue("stream_update_timestamp");
|
|
if($update_time == null){
|
|
$update_time = 0;
|
|
}
|
|
return $update_time;
|
|
}
|
|
|
|
public static function GetClientId() {
|
|
return self::GetValue("client_id");
|
|
}
|
|
|
|
public static function SetClientId($id) {
|
|
if (is_numeric($id)) {
|
|
self::SetValue("client_id", $id);
|
|
}
|
|
}
|
|
|
|
/* User specific preferences start */
|
|
|
|
/**
|
|
* Sets the time scale preference (agendaDay/agendaWeek/month) in Calendar.
|
|
*
|
|
* @param $timeScale new time scale
|
|
*/
|
|
public static function SetCalendarTimeScale($timeScale) {
|
|
self::SetValue("calendar_time_scale", $timeScale, true /* user specific */);
|
|
}
|
|
|
|
/**
|
|
* Retrieves the time scale preference for the current user.
|
|
* Defaults to month if no entry exists
|
|
*/
|
|
public static function GetCalendarTimeScale() {
|
|
$val = self::GetValue("calendar_time_scale", true /* user specific */);
|
|
if(strlen($val) == 0) {
|
|
$val = "month";
|
|
}
|
|
return $val;
|
|
}
|
|
|
|
/**
|
|
* Sets the number of entries to show preference in library under Playlist Builder.
|
|
*
|
|
* @param $numEntries new number of entries to show
|
|
*/
|
|
public static function SetLibraryNumEntries($numEntries) {
|
|
self::SetValue("library_num_entries", $numEntries, true /* user specific */);
|
|
}
|
|
|
|
/**
|
|
* Retrieves the number of entries to show preference in library under Playlist Builder.
|
|
* Defaults to 10 if no entry exists
|
|
*/
|
|
public static function GetLibraryNumEntries() {
|
|
$val = self::GetValue("library_num_entries", true /* user specific */);
|
|
if(strlen($val) == 0) {
|
|
$val = "10";
|
|
}
|
|
return $val;
|
|
}
|
|
|
|
/**
|
|
* Sets the time interval preference in Calendar.
|
|
*
|
|
* @param $timeInterval new time interval
|
|
*/
|
|
public static function SetCalendarTimeInterval($timeInterval) {
|
|
self::SetValue("calendar_time_interval", $timeInterval, true /* user specific */);
|
|
}
|
|
|
|
/**
|
|
* Retrieves the time interval preference for the current user.
|
|
* Defaults to 30 min if no entry exists
|
|
*/
|
|
public static function GetCalendarTimeInterval() {
|
|
$val = self::GetValue("calendar_time_interval", true /* user specific */);
|
|
if(strlen($val) == 0) {
|
|
$val = "30";
|
|
}
|
|
return $val;
|
|
}
|
|
|
|
public static function SetDiskQuota($value){
|
|
self::SetValue("disk_quota", $value, false);
|
|
}
|
|
|
|
public static function GetDiskQuota(){
|
|
$val = self::GetValue("disk_quota");
|
|
if(strlen($val) == 0) {
|
|
$val = "0";
|
|
}
|
|
return $val;
|
|
}
|
|
|
|
public static function SetLiveSteamMasterUsername($value){
|
|
self::SetValue("live_stream_master_username", $value, false);
|
|
}
|
|
|
|
public static function GetLiveSteamMasterUsername(){
|
|
return self::GetValue("live_stream_master_username");
|
|
}
|
|
|
|
public static function SetLiveSteamMasterPassword($value){
|
|
self::SetValue("live_stream_master_password", $value, false);
|
|
}
|
|
|
|
public static function GetLiveSteamMasterPassword(){
|
|
return self::GetValue("live_stream_master_password");
|
|
}
|
|
|
|
public static function SetSourceStatus($sourcename, $status){
|
|
self::SetValue($sourcename, $status, false);
|
|
}
|
|
|
|
public static function GetSourceStatus($sourcename){
|
|
$value = self::GetValue($sourcename);
|
|
if($value == null || $value == "false"){
|
|
return false;
|
|
}else{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static function SetSourceSwitchStatus($sourcename, $status){
|
|
self::SetValue($sourcename."_switch", $status, false);
|
|
}
|
|
|
|
public static function GetSourceSwitchStatus($sourcename){
|
|
$value = self::GetValue($sourcename."_switch");
|
|
if($value == null || $value == "off"){
|
|
return "off";
|
|
}else{
|
|
return "on";
|
|
}
|
|
}
|
|
|
|
public static function SetMasterDJSourceConnectionURL($value){
|
|
self::SetValue("master_dj_source_connection_url", $value, false);
|
|
}
|
|
|
|
public static function GetMasterDJSourceConnectionURL(){
|
|
return self::GetValue("master_dj_source_connection_url");
|
|
}
|
|
|
|
public static function SetLiveDJSourceConnectionURL($value){
|
|
self::SetValue("live_dj_source_connection_url", $value, false);
|
|
}
|
|
|
|
public static function GetLiveDJSourceConnectionURL(){
|
|
return self::GetValue("live_dj_source_connection_url");
|
|
}
|
|
|
|
/* Source Connection URL override status starts */
|
|
public static function GetLiveDjConnectionUrlOverride(){
|
|
return self::GetValue("live_dj_connection_url_override");
|
|
}
|
|
|
|
public static function SetLiveDjConnectionUrlOverride($value){
|
|
self::SetValue("live_dj_connection_url_override", $value, false);
|
|
}
|
|
|
|
public static function GetMasterDjConnectionUrlOverride(){
|
|
return self::GetValue("master_dj_connection_url_override");
|
|
}
|
|
|
|
public static function SetMasterDjConnectionUrlOverride($value){
|
|
self::SetValue("master_dj_connection_url_override", $value, false);
|
|
}
|
|
/* Source Connection URL override status ends */
|
|
|
|
public static function SetAutoTransition($value){
|
|
self::SetValue("auto_transition", $value, false);
|
|
}
|
|
|
|
public static function GetAutoTransition(){
|
|
return self::GetValue("auto_transition");
|
|
}
|
|
|
|
public static function SetAutoSwitch($value){
|
|
self::SetValue("auto_switch", $value, false);
|
|
}
|
|
|
|
public static function GetAutoSwitch(){
|
|
return self::GetValue("auto_switch");
|
|
}
|
|
|
|
public static function SetEnableSystemEmail($upload) {
|
|
self::SetValue("enable_system_email", $upload);
|
|
}
|
|
|
|
public static function GetEnableSystemEmail() {
|
|
$v = self::GetValue("enable_system_email");
|
|
|
|
if ($v === "") {
|
|
return 0;
|
|
}
|
|
|
|
return $v;
|
|
}
|
|
|
|
public static function SetSystemEmail($value) {
|
|
self::SetValue("system_email", $value, false);
|
|
}
|
|
|
|
public static function GetSystemEmail() {
|
|
return self::GetValue("system_email");
|
|
}
|
|
/* User specific preferences end */
|
|
|
|
public static function ShouldShowPopUp(){
|
|
$today = mktime(0, 0, 0, gmdate("m"), gmdate("d"), gmdate("Y"));
|
|
$remindDate = Application_Model_Preference::GetRemindMeDate();
|
|
if($remindDate == NULL || $today >= $remindDate){
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|