PHP Zend_Gdata_Calendar::newEventQuery方法代码示例

function getFeeds($startdate, $enddate)
{
    global $dayinseconds;
    $feeds = array();
    $calendars = array('facultyadmin@communityhigh.net', 'en.usa%23holiday@group.v.calendar.google.com', 'communityhigh.net_cqt4f59nci2gvtftuqseal396o%40group.calendar.google.com', 'communityhigh.net_5d3b9b97gj76hqmk9ir4s2usm8%40group.calendar.google.com');
    foreach ($calendars as $user) {
        /* @var $service Zend_Gdata_Calendar */
        $service = new Zend_Gdata_Calendar();
        /* @var $query Zend_Gdata_Calendar_EventQuery */
        $query = $service->newEventQuery();
        $query->setUser($user);
        $query->setOrderby('starttime');
        $query->setSortOrder('ascending');
        $query->setMaxResults(100000);
        //get days events: event: name, description
        $query->setStartMin(date(DATE_RFC3339, $startdate));
        $query->setStartMax(date(DATE_RFC3339, $enddate + 6 * $dayinseconds));
        try {
            $feeds[] = $service->getCalendarEventFeed($query);
            //foreach($eventFeed as $event)
            // var_dump($event->when);
        } catch (Zend_Gdata_App_Exception $e) {
            echo "Error: " . $e->getMessage();
        }
    }
    return $feeds;
}

 /**
  * Pull the events from google
  * @param <object> $SyncState
  * @return <array> google Records
  */
 public function getCalendar($SyncState)
 {
     $calendars = new Zend_Gdata_Calendar($this->apiInstance);
     $query = $calendars->newEventQuery($query);
     $query->setVisibility('private');
     $query->setMaxResults($this->maxResults);
     $query->setStartIndex(1);
     $query->setOrderBy('lastmodified');
     $query->setsortorder('ascending');
     if (Google_Utils_Helper::getSyncTime('Calendar')) {
         $query->setUpdatedMin(Google_Utils_Helper::getSyncTime('Calendar'));
     }
     $feed = $calendars->getCalendarEventFeed($query);
     $this->totalRecords = $feed->totalResults->text;
     $calendarRecords = array();
     if (count($feed->entry) > 0) {
         $maxModifiedTime = date('Y-m-d H:i:s', strtotime(Google_Contacts_Model::vtigerFormat(end($feed->entry)->updated->text)) + 1);
         if ($this->totalRecords > $this->maxResults) {
             if (!Google_Utils_Helper::getSyncTime('Calendar')) {
                 $query->setUpdatedMin(date('Y-m-d H:i:s', strtotime(Google_Contacts_Model::vtigerFormat(end($feed->entry)->updated->text))));
                 $query->setStartIndex($this->maxResults);
             }
             $query->setMaxResults(500);
             $query->setUpdatedMax($maxModifiedTime);
             $extendedFeed = $calendars->getCalendarEventFeed($query);
             $calendarRecords = array_merge($feed->entry, $extendedFeed->entry);
         } else {
             $calendarRecords = $feed->entry;
         }
     }
     $googleRecords = array();
     foreach ($calendarRecords as $i => $calendar) {
         $recordModel = Google_Calendar_Model::getInstanceFromValues(array('entity' => $calendar));
         $deleted = false;
         if (end(explode('.', $calendar->eventstatus->value)) == 'canceled') {
             $deleted = true;
         }
         if (!$deleted) {
             $recordModel->setType($this->getSynchronizeController()->getSourceType())->setMode(WSAPP_SyncRecordModel::WSAPP_UPDATE_MODE);
         } else {
             $recordModel->setType($this->getSynchronizeController()->getSourceType())->setMode(WSAPP_SyncRecordModel::WSAPP_DELETE_MODE);
         }
         $googleRecords[$calendar->id->text] = $recordModel;
     }
     $this->createdRecords = count($googleRecords);
     if (isset($maxModifiedTime)) {
         Google_Utils_Helper::updateSyncTime('Calendar', $maxModifiedTime);
     } else {
         Google_Utils_Helper::updateSyncTime('Calendar');
     }
     return $googleRecords;
 }

// various copy includes
require_once "../../config.gen.inc.php";
require_once "data/data.inc.php";
// records stats
require_once "../page_builder/page_header.php";
// sets up google calendar classes
require_once "lib/google_calendar.init.php";
// libs
require_once "lib/calendar.lib.php";
require_once "lib/textformat.lib.php";
$search_terms = $_REQUEST['filter'];
$search_options = SearchOptions::get_options();
$timeframe = isset($_REQUEST['timeframe']) ? $_REQUEST['timeframe'] : 0;
$dates = SearchOptions::search_dates($timeframe);
$service = Zend_Gdata_Calendar::AUTH_SERVICE_NAME;
// predefined service name for calendar
$client = Zend_Gdata_ClientLogin::getHttpClient($username . '@gmail.com', $password, $service);
$gdataCal = new Zend_Gdata_Calendar($client);
$query = $gdataCal->newEventQuery();
$query->setUser($calendars['all']['user']);
$query->setVisibility('private');
$query->setProjection('full');
$query->setOrderby('starttime');
$query->setSortorder('a');
$query->setStartMin($dates['start']);
$query->setStartMax($dates['end']);
$query->setmaxresults('50');
$query->setQuery($search_terms);
$eventFeed = $gdataCal->getCalendarEventFeed($query);
require "templates/{$prefix}/search.html";
$page->output();

//.........这里部分代码省略.........
                        $newAccessLevelString = ($pos > 0) ? str_replace($userAccessLevel, $accessLevel, $gIds["$id"]['gAccessLevel']) : $gIds["$id"]['gAccessLevel'] . $accessLevel;
                    }
                    if (strpos($gIds["$id"]['gColor'], $color) === false) {
                        // Change the gCalendar access level
                        $pos = strpos($gIds["$id"]['gColor'], '|' . $user . '$');
                        $userColor = ($pos > 0) ? substr($gIds["$id"]['gColor'], $pos - 8, (int) strlen($user) + 10) : '';
                        $newColorString = ($pos > 0) ? str_replace($userColor, $color, $gIds["$id"]['gColor']) : $gIds["$id"]['gColor'] . $color;
                    }
                    $resp = (strpos($gIds["$id"]['resp'], $resp) === false) ? $resp : '';
                    $items = array('nom_agenda' => $calendar->title,
                        'descriu' => $calendar->summary->text,
                        'gColor' => $newColorString,
                        'resp' => $gIds["$id"]['resp'] . $resp,
                        'gAccessLevel' => $newAccessLevelString);
                    $sv = ModUtil::func('IWmain', 'user', 'genSecurityValue');
                    ModUtil::apiFunc('IWagendas', 'admin', 'editAgenda', array('daid' => $gIds["$id"]['daid'],
                        'items' => $items,
                        'sv' => $sv));
                }
            }
        }
        // Get data from google for 2 months ago and 4 future months more or less
        $time = time();
        $beginDate = $time - 2 * 30 * 24 * 60 * 60;
        $endDate = $time + 4 * 30 * 24 * 60 * 60;
        $beginOndate = date('Y-m-d', $beginDate);
        $endOnDate = date('Y-m-d', $endDate);
        //get all the google notes
        $gCalendarNotes = ModUtil::apiFunc('IWagendas', 'user', 'getAllGCalendarNotes', array('beginDate' => $beginDate,
                    'endDate' => $endDate,
                    'gIds' => $gIds));
        foreach ($calFeed as $calendar) {
            $id = $calendar->id;
            $query = $gdataCal->newEventQuery();
            $calFeed = $gdataCal->getCalendarListFeed();
            $gUser = str_replace(Zend_Gdata_Calendar::CALENDAR_FEED_URI . '/default/', "", $id); // kind of dirty way to get the info, nut it lokks working :)
            $query->setUser($gUser);
            $query->setVisibility('private');
            $query->setProjection('full');
            $query->setOrderby('starttime');
            $query->setStartMin($beginOndate);
            $query->setStartMax($endOnDate);
            $eventFeed = array();
            if ($calendar->accessLevel->value == 'owner' ||
                    $calendar->accessLevel->value == 'editor' ||
                    $calendar->accessLevel->value == 'read') {
                $eventFeed = $gdataCal->getCalendarEventFeed($query);
            }
            foreach ($eventFeed as $event) {
                foreach ($event->when as $when) {
                    $startTime = $when->startTime;
                    $day = substr($startTime, 8, 2);
                    $month = substr($startTime, 5, 2);
                    $year = substr($startTime, 0, 4);
                    $hour = substr($startTime, 11, 2);
                    $minute = substr($startTime, 14, 2);
                    $startTime = gmmktime($hour, $minute, 0, $month, $day, $year);
                    $day = date('d', $startTime);
                    $month = date('m', $startTime);
                    $year = date('Y', $startTime);
                    $hour = date('H', $startTime);
                    $minute = date('i', $startTime);
                    $endTime = $when->endTime;
                    $dayEnd = substr($endTime, 8, 2);
                    $monthEnd = substr($endTime, 5, 2);
                    $yearEnd = substr($endTime, 0, 4);

/**
 * Returns an entry object representing the event with the specified ID.
 *
 * @param  Zend_Http_Client $client  The authenticated client object
 * @param  string           $eventId The event ID string
 * @return Zend_Gdata_Calendar_EventEntry|null if the event is found, null if it's not
 */
function getEvent(Zend_Http_Client $client, $eventId)
{
    $gdataCal = new Zend_Gdata_Calendar($client);
    $query = $gdataCal->newEventQuery();
    $query->setUser('default');
    $query->setVisibility('private');
    $query->setProjection('full');
    $query->setEvent($eventId);
    try {
        $eventEntry = $gdataCal->getCalendarEventEntry($query);
        return $eventEntry;
    } catch (Zend_Gdata_App_Exception $e) {
        return null;
    }
}

 /**
  * List events matching a full text query. Full text query searches
  * both title and event description for matches
  *
  * @param String $client - Access token
  * @param String $eventQuery - Query in string form
  * @return list of matching events in array form
  */
 function calFullTextQuery($client, $eventQuery)
 {
     $gdataCal = new Zend_Gdata_Calendar($client);
     $query = $gdataCal->newEventQuery();
     $query->setUser('default');
     $query->setVisibility('private');
     $query->setProjection('full');
     $query->setQuery($eventQuery);
     $eventFeed = $gdataCal->getCalendarEventFeed($query);
     return $eventFeed;
 }

        function import_google_calendar() {
                ajx_current("empty");
                $users = ExternalCalendarUsers::findByContactId();  
                if($users){
                    $calendars = ExternalCalendars::findByExtCalUserId($users->getId());

                    require_once 'Zend/Loader.php';

                    Zend_Loader::loadClass('Zend_Gdata');
                    Zend_Loader::loadClass('Zend_Gdata_AuthSub');
                    Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
                    Zend_Loader::loadClass('Zend_Gdata_Calendar');

                    $user = $users->getAuthUser();
                    $pass = $users->getAuthPass();
                    $service = Zend_Gdata_Calendar::AUTH_SERVICE_NAME;

                    try
                    {
                            $client = Zend_Gdata_ClientLogin::getHttpClient($user,$pass,$service);                                                       
                            $gdataCal = new Zend_Gdata_Calendar($client);

                            //update or insert events for calendars                        
                            foreach ($calendars as $calendar){

                                //check the deleted calendars
                                $delete_calendar = false;
                                $calFeed = $gdataCal->getCalendarListFeed();        
                                foreach ($calFeed as $calF){
                                    $cal_src = explode("/",$calF->content->src);
                                    array_pop($cal_src);
                                    $calendar_visibility = end($cal_src);
                                    array_pop($cal_src);
                                    $calendar_user = end($cal_src); 

                                    if($calendar_user == $calendar->getCalendarUser()){
                                        $delete_calendar = true;
                                    }
                                }

                                if($delete_calendar){
                                    $calendar_user = $calendar->getCalendarUser();
                                    $calendar_visibility = $calendar->getCalendarVisibility();
                                    $start_sel = date('Y-m-d', strtotime('-1 week'));
                                    $end_sel = date('Y-m-d', strtotime('+2 year'));

                                    $query = $gdataCal->newEventQuery();
                                    $query->setUser($calendar_user);
                                    $query->setVisibility($calendar_visibility);
                                    $query->setSingleEvents(true);
                                    $query->setProjection('full');
                                    $query->setOrderby('starttime');
                                    $query->setSortOrder('ascending'); 
                                    $query->setStartMin($start_sel);
                                    $query->setStartMax($end_sel);
                                    $query->setMaxResults(50);
                                    // execute and get results
                                    $event_list = $gdataCal->getCalendarEventFeed($query);

                                    $array_events_google = array();
                                    foreach ($event_list as $event){                                        
                                        $event_id = explode("/",$event->id->text);
                                        $special_id = end($event_id); 
                                        $event_name = lang("untitle event");
                                        if($event->title->text != ""){
                                            $event_name = $event->title->text;
                                        }
                                        $array_events_google[] = $special_id;
                                        $new_event = ProjectEvents::findBySpecialId($special_id);
                                        if($new_event){
                                            if(strtotime(ProjectEvents::date_google_to_sql($event->updated)) > $new_event->getUpdateSync()->getTimestamp()){
                                                $start = strtotime(ProjectEvents::date_google_to_sql($event->when[0]->startTime));
                                                $fin = strtotime(ProjectEvents::date_google_to_sql($event->when[0]->endTime));
                                                if(($fin - $start) == 86400){
                                                    $new_event->setStart(date("Y-m-d H:i:s",$start));
                                                    $new_event->setDuration(date("Y-m-d H:i:s",$start));
                                                    $new_event->setTypeId(2);
                                                }elseif(($fin - $start) > 86400){                                                
                                                    $t_s = explode(' ', date("Y-m-d H:i:s",$start));
                                                    $t_f = explode(' ', date("Y-m-d H:i:s",$fin));

                                                    $date_s = new DateTimeValue(strtotime($t_s[0]."00:00:00") - logged_user()->getTimezone() * 3600);
                                                    $date_f = new DateTimeValue(strtotime($t_f[0]."23:59:59 -1 day") - logged_user()->getTimezone() * 3600);

                                                    $new_event->setStart(date("Y-m-d H:i:s",$date_s->getTimestamp()));
                                                    $new_event->setDuration(date("Y-m-d H:i:s",$date_f->getTimestamp()));
                                                    $new_event->setTypeId(2);
                                                }else{
                                                    $new_event->setStart(ProjectEvents::date_google_to_sql($event->when[0]->startTime));
                                                    $new_event->setDuration(ProjectEvents::date_google_to_sql($event->when[0]->endTime));
                                                }

                                                $new_event->setObjectName($event_name);
                                                $new_event->setDescription($event->content->text);
                                                $new_event->setUpdateSync(ProjectEvents::date_google_to_sql($event->updated));
                                                $new_event->setExtCalId($calendar->getId());
                                                $new_event->save(); 
                                            }
                                        }else{
                                            $new_event = new ProjectEvent();
//.........这里部分代码省略.........

 /**
  * Do the plugin action
  *
  * @param   array   &$data       selected data
  * @param   object  &$listModel  list model
  *
  * @return number of records updated
  */
 public function process(&$data, &$listModel)
 {
     $params = $this->getParams();
     $gcal_url = $params->get('gcal_sync_gcal_url');
     $matches = array();
     /* This matches a standard GCal URL, found under the Google "Calender Details" tab, using the XML button.
      * It should match any form, for public or private ...
      * http://www.google.com/calendar/feeds/hugh.messenger%40gmail.com/public/basic
      * http://www.google.com/calendar/feeds/hugh.messenger%40gmail.com/private-3081eca2b0asdfasdf8f106ea6f63343056/basic
      */
     if (preg_match('#feeds/(.*?)/(\\w+-\\w+|\\w+)/(\\w+)#', $gcal_url, $matches)) {
         // Grab the bits of the URL we need for the Zend framework call
         $gcal_user = $matches[1];
         $gcal_visibility = $matches[2];
         $gcal_projection = $matches[3];
         $gcal_email = urldecode($gcal_user);
         // Grab the table model and find table name and PK
         $table = $listModel->getTable();
         $table_name = $table->db_table_name;
         /* For now, we have to read the table ourselves.  We can't rely on the $data passed to us
          * because it can be filtered, and we need to see all records to know if the GCal events
          * already exist in the table
          */
         $mydata = array();
         $db = FabrikWorker::getDbo();
         $query = $db->getQuery(true);
         $query->select('*')->from($table_name);
         $db->setQuery($query);
         $mydata[0] = $db->loadObjectList();
         // Grab all the field names to use
         $gcal_label_element_long = $params->get('gcal_sync_label_element');
         $gcal_label_element = FabrikString::shortColName($gcal_label_element_long);
         $gcal_desc_element_long = $params->get('gcal_sync_desc_element');
         $gcal_desc_element = FabrikString::shortColName($gcal_desc_element_long);
         $gcal_start_date_element_long = $params->get('gcal_sync_startdate_element');
         $gcal_start_date_element = FabrikString::shortColName($gcal_start_date_element_long);
         $gcal_end_date_element_long = $params->get('gcal_sync_enddate_element');
         $gcal_end_date_element = FabrikString::shortColName($gcal_end_date_element_long);
         $gcal_id_element_long = $params->get('gcal_sync_id_element');
         $gcal_id_element = FabrikString::shortColName($gcal_id_element_long);
         $gcal_userid_element_long = $params->get('gcal_sync_userid_element');
         $gcal_userid_element = FabrikString::shortColName($gcal_userid_element_long);
         // Sanity check, make sure required elements have been specified
         if (empty($gcal_label_element_long) || empty($gcal_start_date_element_long) || empty($gcal_end_date_element_long) || empty($gcal_id_element_long)) {
             return;
         }
         // If they selected a User ID element to use, see if we can find a J! user with matching email to this feed's owner
         $our_userid = 0;
         if ($gcal_userid_element_long) {
             $query = $db->getQuery(true);
             $query->select('id')->from('#__users')->whre('email = ' . $db->quote('$gcal_email'));
             $db->setQuery($query);
             $our_userid = $db->loadResult();
             // Better make sure it's not NULL, in case underlying column is NOT NULL
             if (empty($our_userid)) {
                 $our_userid = 0;
             }
         }
         // Include the Zend stuff
         $path = JPATH_SITE . '/libraries';
         set_include_path(get_include_path() . PATH_SEPARATOR . $path);
         $path = get_include_path();
         require_once 'Zend/Loader.php';
         Zend_Loader::loadClass('Zend_Gdata');
         /* Won't need these loaded until we add sync'ing events back to Google
          * Zend_Loader::loadClass('Zend_Gdata_AuthSub');
          * Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
          */
         Zend_Loader::loadClass('Zend_Gdata_Calendar');
         // See if they want to sync to gcal, and provided a login
         $gcal_sync_upload = $params->get('gcal_sync_upload_events', 'from');
         if ($gcal_sync_upload == 'both' || $gcal_sync_upload == 'to') {
             Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
             $email = $params->get('gcal_sync_login', '');
             $passwd = $params->get('gcal_sync_passwd', '');
             try {
                 $client = Zend_Gdata_ClientLogin::getHttpClient($email, $passwd, 'cl');
             } catch (Zend_Gdata_App_CaptchaRequiredException $cre) {
                 echo 'URL of CAPTCHA image: ' . $cre->getCaptchaUrl() . "\n";
                 echo 'Token ID: ' . $cre->getCaptchaToken() . "\n";
                 return;
             } catch (Zend_Gdata_App_AuthException $ae) {
                 echo 'Problem authenticating: ' . $ae->exception() . "\n";
                 return;
             }
             $gdataCal = new Zend_Gdata_Calendar($client);
         } else {
             $gdataCal = new Zend_Gdata_Calendar();
         }
         // Set up and execute the call to grab the feed from google
         $query = $gdataCal->newEventQuery();
         $query->setUser($gcal_user);
//.........这里部分代码省略.........

function getEventByUrl($eventEditUrl)
{
    $gdataCal = new Zend_Gdata_Calendar($client);
    $query = $gdataCal->newEventQuery();
    $query->setUser('default');
    $query->setVisibility('private');
    $query->setProjection('full');
    $query->setEvent($eventId);
    try {
        $eventEntry = $gdataCal->getCalendarEventEntry($query);
        return $eventEntry;
    } catch (Zend_Gdata_App_Exception $e) {
        var_dump($e);
        return false;
    }
}

        //echo $uriRedirect;
        $uriCalendar = 'http://www.google.com/calendar/feeds/';
        $hostedDomain = 'nexchie.com';
        $uriGoogleAuth = Zend_Gdata_AuthSub::getAuthSubTokenUri($uriRedirect, $uriCalendar, 0, 1);
        header("Location: " . $uriGoogleAuth . "&hd=nexchie.com");
        //echo $uriGoogleAuth;
        echo "<h1>Googleカレンダータイムシート</h1>";
        echo "<a href='{$uriGoogleAuth}'>ログイン</a>";
    }
}
if (isset($_SESSION['cal_token'])) {
    // 認証済みHTTPクライアント作成
    $client = Zend_Gdata_AuthSub::getHttpClient($_SESSION['cal_token']);
    // Calendarサービスのインスタンス作成
    $service = new Zend_Gdata_Calendar($client);
    $query = $service->newEventQuery();
    $query->setUser('default');
    // MagicCookie 認証の場合は
    // $query->setVisibility('private-magicCookieValue') とします
    $query->setVisibility('private');
    $query->setProjection('full');
    $query->setOrderby('starttime');
    $query->setFutureevents('false');
    $query->setStartMin($_GET[s]);
    $query->setStartMax($_GET[e]);
    //$query->setStartMin('2009-05-01');
    //$query->setStartMax('2009-06-01');
    $query->setmaxResults(999);
    // カレンダーサーバからイベントの一覧を取得します
    try {
        $eventFeed = $service->getCalendarEventFeed($query);

 function loadEventsFromFeed()
 {
     // Create the Calendar client
     $service = Zend_Gdata_Calendar::AUTH_SERVICE_NAME;
     try {
         $client = Zend_Gdata_ClientLogin::getHttpClient($this->user, $this->password, $service);
     } catch (Exception $ex) {
         $this->log("Error: Caught this creating a Gdata client (pi.googlecal_events) : " . $ex->getMessage());
         return;
     }
     $calendar = new Zend_Gdata_Calendar($client);
     $query = $calendar->newEventQuery();
     $query->setVisibility('private');
     $query->setProjection('composite');
     $query->setStartMin($this->calendar_start_date);
     $query->setStartMax($this->calendar_end_date);
     $this->events = array();
     foreach ($this->google_calendars as $google_calendar) {
         $query->setUser($google_calendar);
         try {
             $eventFeed = $calendar->getCalendarEventFeed($query);
         } catch (Exception $ex) {
             $this->log("Error: Caught this retrieving the Google Calendar feed (pi.googlecal_events) : " . $ex->getMessage());
             return;
         }
         $newEvents = $this->parseEventFeed($eventFeed);
         $this->events = array_merge($this->events, $newEvents);
     }
     // Sort the list of events
     usort($this->events, "eventCmp");
 }

 /**
  * @return Zend_Gdata_App_Entry|NULL
  */
 public static function internalGetEvent($calendar, $eventId)
 {
     try {
         $client = new Zend_Http_Client();
         if (!empty($calendar->username) && !empty($calendar->password)) {
             $client = Zend_Gdata_ClientLogin::getHttpClient($calendar->username, $calendar->password, Zend_Gdata_Calendar::AUTH_SERVICE_NAME);
         }
         $service = new Zend_Gdata_Calendar($client);
         $query = $service->newEventQuery();
         $query->setUser($calendar->calendar_id);
         if ($calendar->magic_cookie != null) {
             $query->setVisibility('private-' . $calendar->magic_cookie);
         }
         $query->setProjection('full');
         $query->setEvent($eventId);
         $query->setParam('ctz', 'Etc/GMT');
         $query->setParam('hl', GCalendarUtil::getFrLanguage());
         $event = $service->getEntry($query, 'GCalendar_Entry');
         $event->setParam('gcid', $calendar->id);
         $event->setParam('gccolor', $calendar->color);
         $event->setParam('gcname', $calendar->name);
         return $event;
     } catch (Zend_Gdata_App_Exception $e) {
         JError::raiseWarning(200, $e->getMessage());
         return null;
     }
 }

/**
 * Iterate through all the Google Calendars and create a JSON encoded array of events.
 *
 * @return array of events in JSON format
 */
function outputCalendarByDateRange($client, $startDate, $endDate, $idsofcal, $gcalobj)
{
    $gdataCal = new Zend_Gdata_Calendar($client);
    $rows = array();
    $idsofcal = explode(',', $idsofcal);
    $calFeed = $gdataCal->getCalendarListFeed();
    foreach ($idsofcal as $idofcal) {
        if ($idofcal != '') {
            $query = $gdataCal->newEventQuery();
            $query->setUser(substr($idofcal, strrpos($idofcal, "/") + 1));
            $query->setVisibility('private');
            $query->setProjection('full');
            $query->setOrderby('starttime');
            $query->setStartMin($startDate);
            $query->setStartMax($endDate);
            $eventFeed = $gdataCal->getCalendarEventFeed($query);
            $color = CALENDAR_DEF_COLOR;
            $accesslevl = true;
            foreach ($calFeed as $calendar) {
                if (strpos($idofcal, $calendar->id->text) !== false) {
                    $color = $calendar->color->value;
                    if ($calendar->accesslevel->value == 'read') {
                        $accesslevl = false;
                    }
                }
            }
            foreach ($eventFeed as $event) {
                foreach ($event->when as $when) {
                    $startD = substr($when->startTime, 0, 19);
                    $startD = str_replace('T', ' ', $startD);
                    $endD = substr($when->endTime, 0, 19);
                    $endD = str_replace('T', ' ', $endD);
                    /*
                     * If both start time and end time are different and their time parts differ then allDay is false
                     */
                    if ($startD != $endD && substr($startD, 0, 10) == substr($endD, 0, 10)) {
                        $allDay = "false";
                    } else {
                        $allDay = "true";
                    }
                    $row = array();
                    $row["title"] = $event->title->text;
                    $row["id"] = $event->id->text;
                    $row["editable"] = $accesslevl;
                    $row["start"] = $startD;
                    $row["end"] = $endD;
                    $row["allDay"] = $allDay;
                    $row["color"] = $color;
                    $row["textColor"] = "white";
                    $row["calendar"] = "Google Calendar event";
                    array_push($rows, $row);
                }
            }
        }
    }
    //Encode in JSON format.
    $str = json_encode($rows);
    //Replace "true","false" with true,false for javascript.
    $str = str_replace('"true"', 'true', $str);
    $str = str_replace('"false"', 'false', $str);
    //Return the events in the JSON format.
    echo $str;
}