PHP Zend_Gdata_Calendar::insertEvent方法代码示例

function g_cal_createEvent($client, $title = 'Untitled', $desc = '', $where = '', $startDate = '2008-01-01', $startTime = '0', $endDate = '2008-01-01', $endTime = '0', $tzOffset = '-08')
{
    $gdataCal = new Zend_Gdata_Calendar($client);
    $newEvent = $gdataCal->newEventEntry();
    $newEvent->title = $gdataCal->newTitle($title);
    $newEvent->where = array($gdataCal->newWhere($where));
    $newEvent->content = $gdataCal->newContent("{$desc}");
    if ($startTime == '0' || $startTime == '') {
        //Make this an All-Day Event
        $when = $gdataCal->newWhen();
        $when->startTime = "{$startDate}";
        $when->endTime = "{$endDate}";
    } else {
        $when = $gdataCal->newWhen();
        $when->startTime = "{$startDate}T{$startTime}:00.000{$tzOffset}:00";
        $when->endTime = "{$endDate}T{$endTime}:00.000{$tzOffset}:00";
    }
    $newEvent->when = array($when);
    // Upload the event to the calendar server
    // A copy of the event as it is recorded on the server is returned
    $createdEvent = $gdataCal->insertEvent($newEvent);
    /*
      //Store the new eventID in the cohelitack database
    	//g_cal_updateEvent($client, $createdEvent->id, "New Title");
    	echo "\$event->getLink('edit')->href: " . $createdEvent->getLink('edit')->href . "<br>\n";
    	echo "\$event->getId(): " . $createdEvent->getId() . "<br>\n";
    	
    	$myEvent = getEvent($client,$createdEvent->getId());
    	echo "\$myEvent->getId(): " . $myEvent->getId() . "<br>\n";
    	
    	//g_cal_deleteEventByUrl($client,$createdEvent->getLink('edit')->href);
    	//g_cal_deleteEventById($client,$createdEvent->getId());
    */
    return $createdEvent->getLink('edit')->href;
}

 function addEvent($title = 'Новый заказ', $desc = 'Описание заказа', $where = 'интернет-магазин', $startDate, $endDate, $sms_reminder)
 {
     try {
         set_include_path('.' . PATH_SEPARATOR . $_SERVER['DOCUMENT_ROOT'] . '/modules/gcalendar/' . PATH_SEPARATOR . get_include_path());
         include_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_HttpClient');
         Zend_Loader::loadClass('Zend_Gdata_Calendar');
         $client = Zend_Gdata_ClientLogin::getHttpClient($this->_user, $this->_pass, "cl");
         $gdataCal = new Zend_Gdata_Calendar($client);
         $newEvent = $gdataCal->newEventEntry();
         $newEvent->title = $gdataCal->newTitle($title);
         $newEvent->where = array($gdataCal->newWhere($where));
         $newEvent->content = $gdataCal->newContent($desc);
         $when = $gdataCal->newWhen();
         $when->startTime = $startDate;
         $when->endTime = $endDate;
         if (intval($sms_reminder)) {
             $reminder = $gdataCal->newReminder();
             $reminder->method = "sms";
             $reminder->minutes = "0";
             $when->reminders = array($reminder);
         }
         $newEvent->when = array($when);
         $createdEvent = $gdataCal->insertEvent($newEvent);
         return $createdEvent->id->text;
     } catch (Exception $ex) {
         // Report the exception to the user
     }
 }

 public function setPlanning($startDate, $endDate, $title, $content)
 {
     // Parameters for ClientAuth authentication
     ProjectConfiguration::registerZend();
     Zend_Loader::loadClass('Zend_Gdata');
     Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
     Zend_Loader::loadClass('Zend_Gdata_Calendar');
     $service = Zend_Gdata_Calendar::AUTH_SERVICE_NAME;
     $user = sfConfig::get('app_gmail_user');
     $pass = sfConfig::get('app_gmail_pwd');
     // Create an authenticated HTTP client
     $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
     // Create an instance of the Calendar service
     $service = new Zend_Gdata_Calendar($client);
     // Create a new entry using the calendar service's magic factory method
     $event = $service->newEventEntry();
     // Populate the event with the desired information
     // Note that each attribute is crated as an instance of a matching class
     $event->title = $service->newTitle($title);
     $event->where = array($service->newWhere("Paris, France"));
     $event->content = $service->newContent($content);
     // Set the date using RFC 3339 format.
     $tzOffset = "+02";
     $when = $service->newWhen();
     //$when->startTime = "{$start_date}.000{$tzOffset}:00";
     //$when->endTime = "{$end_date}.000{$tzOffset}:00";
     $when->startTime = "{$startDate}:00.000{$tzOffset}:00";
     $when->endTime = "{$endDate}:00.000{$tzOffset}:00";
     $event->when = array($when);
     // Upload the event to the calendar server
     // A copy of the event as it is recorded on the server is returned
     $newEvent = $service->insertEvent($event);
 }

function createEvent($client, $title = 'Tennis with Beth', $desc = 'Meet for a quick lesson', $startDate = '2012-01-20', $endDate = '2012-01-20')
{
    $gdataCal = new Zend_Gdata_Calendar($client);
    $newEvent = $gdataCal->newEventEntry();
    $newEvent->title = $gdataCal->newTitle($title);
    //$newEvent->where = array($gdataCal->newWhere($where));
    $newEvent->content = $gdataCal->newContent("{$desc}");
    $when = $gdataCal->newWhen();
    $when->startTime = "{$startDate}";
    $when->endTime = "{$endDate}";
    $newEvent->when = array($when);
    // Upload the event to the calendar server
    // A copy of the event as it is recorded on the server is returned
    $createdEvent = $gdataCal->insertEvent($newEvent);
    return $createdEvent->id->text;
}

/**
 * Creates an event on the authenticated user's default calendar with the
 * specified event details.
 *
 * @param  Zend_Http_Client $client    The authenticated client object
 * @param  string           $title     The event title
 * @param  string           $desc      The detailed description of the event
 * @param  string           $startDate The start date of the event in YYYY-MM-DD format
 * @param  string           $startTime The start time of the event in HH:MM 24hr format
 * @param  string           $endTime   The end time of the event in HH:MM 24hr format
 * @param  string           $tzOffset  The offset from GMT/UTC in [+-]DD format (eg -08)
 * @return string
 */
function createEvent(Zend_Http_Client $client, $title = 'Tennis with Beth', $desc = 'Meet for a quick lesson', $where = 'On the courts', $startDate = '2008-01-20', $startTime = '10:00', $endDate = '2008-01-20', $endTime = '11:00', $tzOffset = '-08')
{
    $gc = new Zend_Gdata_Calendar($client);
    $newEntry = $gc->newEventEntry();
    $newEntry->title = $gc->newTitle(trim($title));
    $newEntry->where = array($gc->newWhere($where));
    $newEntry->content = $gc->newContent($desc);
    $newEntry->content->type = 'text';
    $when = $gc->newWhen();
    $when->startTime = "{$startDate}T{$startTime}:00.000{$tzOffset}:00";
    $when->endTime = "{$endDate}T{$endTime}:00.000{$tzOffset}:00";
    $newEntry->when = array($when);
    $createdEntry = $gc->insertEvent($newEntry);
    return $createdEntry->id->text;
}

/**
 * Creates a new web content event on the authenticated user's default 
 * calendar with the specified event details. For simplicity, the event 
 * is created as an all day event and does not include a description.
 *
 * @param Zend_Http_Client $client The authenticated client object
 * @param string $title The event title
 * @param string $startDate The start date of the event in YYYY-MM-DD format
 * @param string $endDate The end time of the event in HH:MM 24hr format
 * @param string $icon URL pointing to a 16x16 px icon representing the event.
 * @param string $url The URL containing the web content for the event.
 * @param string $height The desired height of the web content pane.
 * @param string $width The desired width of the web content pane.
 * @param string $type The MIME type of the web content.
 * @return string The ID URL for the event.
 */
function createWebContentEvent($client, $title = 'World Cup 2006', $startDate = '2006-06-09', $endDate = '2006-06-09', $icon = 'http://www.google.com/calendar/images/google-holiday.gif', $url = 'http://www.google.com/logos/worldcup06.gif', $height = '120', $width = '276', $type = 'image/gif')
{
    $gc = new Zend_Gdata_Calendar($client);
    $newEntry = $gc->newEventEntry();
    $newEntry->title = $gc->newTitle(trim($title));
    $when = $gc->newWhen();
    $when->startTime = $startDate;
    $when->endTime = $endDate;
    $newEntry->when = array($when);
    $wc = $gc->newWebContent();
    $wc->url = $url;
    $wc->height = $height;
    $wc->width = $width;
    $wcLink = $gc->newLink();
    $wcLink->rel = "http://schemas.google.com/gCal/2005/webContent";
    $wcLink->title = $title;
    $wcLink->type = $type;
    $wcLink->href = $icon;
    $wcLink->webContent = $wc;
    $newEntry->link = array($wcLink);
    $createdEntry = $gc->insertEvent($newEntry);
    return $createdEntry->id->text;
}

 function created_event_google_calendar($object, $event)
 {
     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');
     $users = ExternalCalendarUsers::findByContactId();
     $calendar = ExternalCalendars::findById($event->getExtCalId());
     $user = $users->getAuthUser();
     $pass = $users->getAuthPass();
     $service = Zend_Gdata_Calendar::AUTH_SERVICE_NAME;
     $client = Zend_Gdata_ClientLogin::getHttpClient($user, $pass, $service);
     $calendarUrl = 'http://www.google.com/calendar/feeds/' . $calendar->getCalendarUser() . '/private/full';
     $gdataCal = new Zend_Gdata_Calendar($client);
     $newEvent = $gdataCal->newEventEntry();
     $newEvent->title = $gdataCal->newTitle($event->getObjectName());
     $newEvent->content = $gdataCal->newContent($event->getDescription());
     $star_time = explode(" ", $event->getStart()->format("Y-m-d H:i:s"));
     $end_time = explode(" ", $event->getDuration()->format("Y-m-d H:i:s"));
     if ($event->getTypeId() == 2) {
         $when = $gdataCal->newWhen();
         $when->startTime = $star_time[0];
         $when->endTime = $end_time[0];
         $newEvent->when = array($when);
     } else {
         $when = $gdataCal->newWhen();
         $when->startTime = $star_time[0] . "T" . $star_time[1] . ".000-00:00";
         $when->endTime = $end_time[0] . "T" . $end_time[1] . ".000-00:00";
         $newEvent->when = array($when);
     }
     // insert event
     $createdEvent = $gdataCal->insertEvent($newEvent, $calendarUrl);
     $event_id = explode("/", $createdEvent->id->text);
     $special_id = end($event_id);
     $event->setSpecialID($special_id);
     $event->setExtCalId($calendar->getId());
     $event->save();
 }

 /**
  * Create a quick event from string input.
  * 
  * Should include time (am/pm), day of the week.
  *
  * Day of the week can be specified as "tomorrow"
  *
  * Can specify week as well with "next tuesday"
  *
  * A day without a modifier will default to that current week,
  * even if the day has already past
  *
  * @param String $client - Access token
  * @param String $quickAddText - Event description
  */
 function createQuickEvent($client, $quickAddText)
 {
     $gdataCal = new Zend_Gdata_Calendar($client);
     $event = $gdataCal->newEventEntry();
     $event->content = $gdataCal->newContent($quickAddText);
     $event->quickAdd = $gdataCal->newQuickAdd('true');
     $newEvent = $gdataCal->insertEvent($event);
 }

        function export_google_calendar() {
		ajx_current("empty");
                
                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');
                
                $users = ExternalCalendarUsers::findByContactId();
                if($users){
                    if($users->getSync() == 1){
                        $sql = "SELECT ec.* FROM `".TABLE_PREFIX."external_calendars` ec,`".TABLE_PREFIX."external_calendar_users` ecu 
                                WHERE ec.calendar_feng = 1 AND ecu.contact_id = ".logged_user()->getId();
                        $calendar_feng = DB::executeOne($sql);
                        $events = ProjectEvents::findNoSync();

                        $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);

                                if ($calendar_feng){
                                    foreach ($events as $event){
                                        $calendarUrl = 'http://www.google.com/calendar/feeds/'.$calendar_feng['calendar_user'].'/private/full';

                                        $newEvent = $gdataCal->newEventEntry();
                                        $newEvent->title = $gdataCal->newTitle($event->getObjectName());
                                        $newEvent->content = $gdataCal->newContent($event->getDescription());

                                        $star_time = explode(" ",$event->getStart()->format("Y-m-d H:i:s"));
                                        $end_time = explode(" ",$event->getDuration()->format("Y-m-d H:i:s"));

                                        if($event->getTypeId() == 2){
                                            $when = $gdataCal->newWhen();
                                            $when->startTime = $star_time[0];
                                            $when->endTime = $end_time[0];
                                            $newEvent->when = array($when);
                                        }else{                                    
                                            $when = $gdataCal->newWhen();
                                            $when->startTime = $star_time[0]."T".$star_time[1].".000-00:00";
                                            $when->endTime = $end_time[0]."T".$end_time[1].".000-00:00";
                                            $newEvent->when = array($when);
                                        }

                                        // insert event
                                        $createdEvent = $gdataCal->insertEvent($newEvent, $calendarUrl);

                                        $event_id = explode("/",$createdEvent->id->text);
                                        $special_id = end($event_id); 
                                        $event->setSpecialID($special_id);
                                        $event->setUpdateSync(ProjectEvents::date_google_to_sql($createdEvent->updated));
                                        $event->setExtCalId($calendar_feng['id']);
                                        $event->save();
                                    }                             
                                }else{
                                    $appCalUrl = '';
                                    $calFeed = $gdataCal->getCalendarListFeed();        
                                    foreach ($calFeed as $calF){
                                        $instalation = explode("/", ROOT_URL);
                                        $instalation_name = end($instalation);
                                        if($calF->title->text == lang('feng calendar',$instalation_name)){
                                            $appCalUrl = $calF->content->src;
                                            $t_calendario = $calF->title->text;
                                        }
                                    }    

                                    if($appCalUrl != ""){
                                        $title_cal = $t_calendario;
                                    }else{
                                        $instalation = explode("/", ROOT_URL);
                                        $instalation_name = end($instalation);
                                        $appCal = $gdataCal -> newListEntry();
                                        $appCal -> title = $gdataCal-> newTitle(lang('feng calendar',$instalation_name));                         
                                        $own_cal = "http://www.google.com/calendar/feeds/default/owncalendars/full";                        
                                        $new_cal = $gdataCal->insertEvent($appCal, $own_cal);

                                        $title_cal = $new_cal->title->text;
                                        $appCalUrl = $new_cal->content->src;                                
                                    }               

                                    $cal_src = explode("/",$appCalUrl);
                                    array_pop($cal_src);
                                    $calendar_visibility = end($cal_src);
                                    array_pop($cal_src);
                                    $calendar_user = end($cal_src);                            

                                    $calendar = new ExternalCalendar();
                                    $calendar->setCalendarUser($calendar_user);
                                    $calendar->setCalendarVisibility($calendar_visibility);
                                    $calendar->setCalendarName($title_cal);
                                    $calendar->setExtCalUserId($users->getId());
                                    $calendar->setCalendarFeng(1);
                                    $calendar->save();

//.........这里部分代码省略.........

//.........这里部分代码省略.........
             $gcal_event_ids[$short_id] = $eventFeed[$key];
         }
         /* Run through our table data, and build an array of our events indexed by the Google ID
          * (of course not all events may have a Google ID)
          */
         $our_event_ids = array();
         $our_upload_ids = array();
         foreach ($mydata as $gkey => $group) {
             if (is_array($group)) {
                 foreach ($group as $rkey => $row) {
                     if ($row->{$gcal_id_element}) {
                         $our_event_ids[$row->{$gcal_id_element}] = $mydata[$gkey][$rkey];
                     } else {
                         $our_upload_ids[] = $mydata[$gkey][$rkey];
                     }
                 }
             }
         }
         // Now go through the google events id's, and process the ones which aren't in our table.
         $our_event_adds = array();
         foreach ($gcal_event_ids as $id => $event) {
             if (!array_key_exists($id, $our_event_ids)) {
                 // we don't have the ID, so add the event to our table
                 $row = array();
                 $row[$gcal_start_date_element] = strftime('%Y-%m-%d %H:%M:%S', strtotime($event->when[0]->startTime));
                 $row[$gcal_end_date_element] = strftime('%Y-%m-%d %H:%M:%S', strtotime($event->when[0]->endTime));
                 $row[$gcal_label_element] = $event->title->text;
                 $row[$gcal_desc_element] = $event->content->text;
                 $row[$gcal_id_element] = $id;
                 if ($gcal_userid_element_long) {
                     $row[$gcal_userid_element] = $our_userid;
                 }
                 $listModel->storeRow($row, 0);
             }
         }
         // If upload syncing (from us to gcal) is enabled ...
         if ($gcal_sync_upload == 'both' || $gcal_sync_upload == 'to') {
             // Grab the tzOffset.  Note that gcal want +/-XX (like -06)
             // but J! gives us +/-X (like -6) so we sprintf it to the right format
             $config = JFactory::getConfig();
             $tzOffset = (int) $config->getValue('config.offset');
             $tzOffset = sprintf('%+03d', $tzOffset);
             // Loop thru the array we built earlier of events we have that aren't in gcal
             foreach ($our_upload_ids as $id => $event) {
                 // Skip if a userid element is specified, and doesn't match the owner of this gcal
                 if ($gcal_userid_element_long) {
                     if ($event->{$gcal_userid_element} != $our_userid) {
                         continue;
                     }
                 }
                 // Now start building the gcal event structure
                 $newEvent = $gdataCal->newEventEntry();
                 $newEvent->title = $gdataCal->newTitle($event->{$gcal_label_element});
                 if ($gcal_desc_element_long) {
                     $newEvent->content = $gdataCal->newContent($event->{$gcal_desc_element});
                 } else {
                     $newEvent->content = $gdataCal->newContent($event->{$gcal_label_element});
                 }
                 $when = $gdataCal->newWhen();
                 // Grab the start date, apply the tx offset, and format it for gcal
                 $start_date = JFactory::getDate($event->{$gcal_start_date_element});
                 $start_date->setOffset($tzOffset);
                 $start_fdate = $start_date->toFormat('%Y-%m-%d %H:%M:%S');
                 $date_array = explode(' ', $start_fdate);
                 $when->startTime = "{$date_array[0]}T{$date_array[1]}.000{$tzOffset}:00";
                 /* We have to provide an end date for gcal, so if we don't have one,
                  * default it to start date + 1 hour
                  */
                 if ($event->{$gcal_end_date_element} == '0000-00-00 00:00:00') {
                     $startstamp = strtotime($event->{$gcal_start_date_element});
                     $endstamp = $startstamp + 60 * 60;
                     $event->{$gcal_end_date_element} = strftime('%Y-%m-%d %H:%M:%S', $endstamp);
                 }
                 // Grab the end date, apply the tx offset, and format it for gcal
                 $end_date = JFactory::getDate($event->{$gcal_end_date_element});
                 $end_date->setOffset($tzOffset);
                 $end_fdate = $end_date->toFormat('%Y-%m-%d %H:%M:%S');
                 $date_array = explode(' ', $end_fdate);
                 $when->endTime = "{$date_array[0]}T{$date_array[1]}.000{$tzOffset}:00";
                 $newEvent->when = array($when);
                 // Fire off the insertEvent to gcal, catch any errors
                 try {
                     $retEvent = $gdataCal->insertEvent($newEvent);
                 } catch (Zend_Gdata_App_HttpException $he) {
                     $errStr = 'Problem adding event: ' . $he->getRawResponseBody() . "\n";
                     continue;
                 }
                 /* So, insertEvent worked, grab the gcal ID from the returned event data,
                  * and update our event record with the short version of the ID
                  */
                 $gcal_id = $this->_getGcalShortId($retEvent->id->text);
                 $our_id = $event->id;
                 $query = $db->getQuery(true);
                 $query->update($table_name)->set($gcal_id_element . ' = ' . $db->quote($gcal_id))->where('id = ' . $db->quote($our_id));
                 $db->setQuery($query);
                 $db->query();
             }
         }
     }
 }

 for ($i = 1; $i <= $num; $i++) {
     // ensure that when POST  variables are extracted  during loops, the abbr is not incorrect
     $abbreviation = strtoupper($abbreviation);
     if (isset($_POST["abbreviation"]) && $abbreviation == "") {
         $abbreviation = strtoupper($_POST[name]);
     }
     // I actually had to guess this method based on Google API's "magic" factory
     $appCal = $gdataCal->newListEntry();
     // I only set the title, other options like color are available.
     $appCal->title = $gdataCal->newTitle($abbreviation . $i);
     //This is the right URL to post to for new calendars...
     //Notice that the user's info is nowhere in there
     $own_cal = "http://www.google.com/calendar/feeds/default/owncalendars/full";
     //And here's the payoff.
     //Use the insertEvent method, set the second optional var to the right URL
     $gdataCal->insertEvent($appCal, $own_cal);
     $calFeed = $gdataCal->getCalendarListFeed();
     foreach ($calFeed as $calendar) {
         if ($calendar->title->text == $abbreviation . $i) {
             //This is the money, you need to use '->content-src'
             //Anything else and you have to manipulate it to get it right.
             $appCalUrl = $calendar->content->src;
         }
     }
     extract($_POST);
     //set POST variables
     $calurl = substr($appCalUrl, 38, strlen($appCalUrl) - 51);
     $url = "http://www.google.com/calendar/feeds/" . $calurl . "/acl/full";
     $post_fields = "<entry xmlns='http://www.w3.org/2005/Atom' xmlns:gAcl='http://schemas.google.com/acl/2007'>\n            <category scheme='http://schemas.google.com/g/2005#kind'\n            term='http://schemas.google.com/acl/2007#accessRule'/>\n            <gAcl:scope type='default'></gAcl:scope>\n            <gAcl:role value='http://schemas.google.com/gCal/2005#read'></gAcl:role>\n            </entry>";
     $gdataCal = new Zend_Gdata_Calendar($client);
     $gdataCal->post($post_fields, $url);

 static function saveEvent(&$newEvent, $bean, $user)
 {
     $client = self::getClient($user);
     if ($client != false) {
         $gdataCal = new Zend_Gdata_Calendar($client);
         if (empty($newEvent->id->text)) {
             try {
                 // Upload the event to the calendar server
                 // A copy of the event as it is recorded on the server is returned
                 $createdEvent = $gdataCal->insertEvent($newEvent);
             } catch (Zend_Gdata_App_Exception $e) {
                 var_dump($e->getResponse());
                 $GLOBALS['log']->error("Failed to insert Event in GoogleCalender: " . print_r($e->getMessage(), 1));
                 die;
             }
         } else {
             try {
                 $newEvent->save();
                 $createdEvent = $newEvent;
             } catch (Zend_Gdata_App_Exception $e) {
                 var_dump($e->getResponse());
                 $GLOBALS['log']->error("Failed to update Event in GoogleCalender: " . print_r($e->getMessage(), 1));
                 die;
             }
         }
         $gs = new GoogleSync();
         if ($gsid = self::getGoogleEntryId($bean, $user)) {
             $gs->retrieve($gsid);
         }
         $gs->parent_name = $bean->module_dir;
         $gs->parent_id = $bean->id;
         // Had to be saved already!;
         $gs->user_id = $user->id;
         $gs->google_id = $createdEvent->id->text;
         $gs->save();
     }
 }

 /**
  * Push the vtiger records to google
  * @param <array> $records vtiger records to be pushed to google
  * @return <array> pushed records
  */
 public function push($records)
 {
     foreach ($records as $record) {
         $entity = $record->get('entity');
         $gContact = new Zend_Gdata_Calendar($this->apiInstance);
         try {
             if ($record->getMode() == WSAPP_SyncRecordModel::WSAPP_UPDATE_MODE) {
                 $createdEntry = $entity->save(null, null, array('If-Match' => '*'));
                 $record->set('entity', $createdEntry);
             } else {
                 if ($record->getMode() == WSAPP_SyncRecordModel::WSAPP_DELETE_MODE) {
                     $createdEntry = $entity->delete();
                     $record->set('entity', $entity);
                 } else {
                     $createdEntry = $gContact->insertEvent($entity);
                     $record->set('entity', $createdEntry);
                 }
             }
         } catch (Exception $e) {
             continue;
         }
     }
     return $records;
 }

    for ($privacy = $_POST["privacy"]; $privacy <= $maxPrivacy; $privacy++) {
        $gc = new Zend_Gdata_Calendar($_SESSION["client"]);
        $newEntry = $gc->newEventEntry();
        $newEntry->title = $gc->newTitle($_POST["name"]);
        $newEntry->where = array($gc->newWhere($_POST["location"]));
        $newEntry->content = $gc->newContent($_POST["info"]);
        $newEntry->content->type = 'text';
        $when = $gc->newWhen();
        $calStartDate = date('c', strtotime($startDatetime));
        $calEndDate = date('c', strtotime($endDatetime));
        $when->startTime = $calStartDate;
        $when->endTime = $calEndDate;
        $newEntry->when = array($when);
        $url = query("SELECT link FROM calendarLinks WHERE id = ?", $_POST["club"] . "." . $privacy);
        $url = $url[0]["link"];
        $createdEntry = $gc->insertEvent($newEntry, $url);
    }
    //redirect to home page
    redirect("/");
} else {
    // create list of clubs that the currently logged in user owns
    $privacy = query("SELECT * FROM privacy WHERE description = 'admin'");
    $privacy = $privacy[0]["level"];
    $rows = query("SELECT * FROM subscriptions WHERE userID = ? AND level = ?", $_SESSION["id"], $privacy);
    $clubsOwned = array();
    foreach ($rows as $row) {
        $club = query("SELECT * FROM clubs WHERE id = ?", $row["clubID"]);
        $clubsOwned[$row["clubID"]] = $club[0]["name"];
    }
    // create list of privacy settings to display on form
    $rows = query("SELECT * FROM privacy");

//.........这里部分代码省略.........
                                $event->delete();
                            } catch (Zend_Gdata_App_Exception $e) {
                                return $this->__('You are not allowed to administrate the agendas');
                            }
                        }
                    }
                }
            }
        }
        // Delete the calendars where user can't access any more
        $diff = array_diff_key($gIds, $existingCalendar);
        foreach ($diff as $d) {
            if ($resp == '$') {
                // Nobody else needs the calendar and it is deleted
                $sv = ModUtil::func('IWmain', 'user', 'genSecurityValue');
                ModUtil::apiFunc('IWagendas', 'admin', 'delete', array('daid' => $d['daid'],
                    'sv' => $sv));
            } else {
                // The user access to the calendar is deleted
                $items = array('gColor' => $newColorString,
                    'resp' => $resp,
                    'gAccessLevel' => $newAccessLevelString);
                $sv = ModUtil::func('IWmain', 'user', 'genSecurityValue');
                ModUtil::apiFunc('IWagendas', 'admin', 'editAgenda', array('daid' => $d['daid'],
                    'items' => $items,
                    'sv' => $sv));
            }
        }
        // set as deleted the not existing gCalendar notes
        $diff = array_diff_key($gCalendarNotes, $existing);
        foreach ($diff as $d) {
            if (strpos($gAgendas[$d['daid']]['gAccessLevel'], '$free|' . $user . '$') === false) {
                $items = array('deleted' => 1,
                    'protegida' => 0);
                $lid = ModUtil::apiFunc('IWagendas', 'user', 'editNote', array('aid' => $d['aid'],
                            'daid' => $d['daid'],
                            'items' => $items));
            }
        }
        //save that the sincronization has been made
        $sv = ModUtil::func('IWmain', 'user', 'genSecurityValue');
        ModUtil::func('IWmain', 'user', 'userSetVar', array('uid' => $user,
            'name' => 'sincroGCalendar',
            'module' => 'IWagendas',
            'sv' => $sv,
            'value' => '1',
            'lifetime' => $userSettings['gRefreshTime'] * 60));
        //get all notes from gCalendar that has been created without connexion and create them
        $notesNotInGCalendar = ModUtil::apiFunc('IWagendas', 'user', 'getAllGCalendarNotes', array('beginDate' => $beginDate,
                    'endDate' => $endDate,
                    'gIds' => $gIds,
                    'notInGCalendar' => 1));
        foreach ($notesNotInGCalendar as $note) {
            $data = $note['data'];
            $data1 = $note['data1'];
            //Protect correct format for dateStart and dataEnd
            if ($data1 < $data)
                $data1 = $data;
            // Create a new entry using the calendar service's magic factory method
            $event = $gdataCal->newEventEntry();
            // Populate the event with the desired information
            // Note that each attribute is crated as an instance of a matching class
            $event->title = $gdataCal->newTitle($note['c1']);
            $event->where = array($gdataCal->newWhere($note['c3']));
            $event->content = $gdataCal->newContent($note['c4']);
            // Set the date using RFC 3339 format.
            $startDate = date('Y-m-d', $data);
            $endDate = date('Y-m-d', $data1);
            $when = $gdataCal->newWhen();
            if ($note['totdia'] == 0) {
                $tzOffset = ($userSettings['tzOffset'] == '') ? '+02' : $userSettings['tzOffset'];
                //protect correct time format
                $startTime = date('H:i', $data);
                $endTime = date('H:i', $data1);
                $when->startTime = "{$startDate}T{$startTime}:00.000{$tzOffset}:00";
                $when->endTime = "{$endDate}T{$endTime}:00.000{$tzOffset}:00";
            } else {
                $when->startTime = "$startDate";
                $when->endTime = "$endDate";
            }
            $event->when = array($when);
            $calendarURL = str_replace(Zend_Gdata_Calendar::CALENDAR_FEED_URI . '/default/', "", $gAgendas[$note['daid']]['gCalendarId']);
            $calendarURL = 'http://www.google.com/calendar/feeds/' . $calendarURL . '/private/full';
            // Upload the event to the calendar server
            // A copy of the event as it is recorded on the server is returned
            try {
                $newEvent = $gdataCal->insertEvent($event, $calendarURL);
            } catch (Zend_Gdata_App_Exception $e) {
                return $this->__('Error produced during gCalendar\'s event creation');
            }
            $gCalendarEventId = $newEvent->id;
            // Edit note gCalendarEventId
            $items = array('gCalendarEventId' => $gCalendarEventId);
            //modify of a simple entry
            $lid = ModUtil::apiFunc('IWagendas', 'user', 'editNote', array('aid' => $note['aid'],
                        'items' => $items,
                        'daid' => $note['daid']));
        }
        return true;
    }