PHP Zend_Gdata_Calendar::newEventEntry方法代码示例

 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 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;
}

 /**
  * 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           $where
  * @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           $endDate   The end date of the event in YYYY-MM-DD 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 The ID URL for the event.
  */
 function createEvent($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;
 }

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;
}

 static function getEvent($bean, $user)
 {
     $client = self::getClient($user);
     if ($client != false) {
         $gdataCal = new Zend_Gdata_Calendar($client);
         $newEvent = null;
         $gid = self::getGoogleId($bean, $user);
         if ($gid) {
             try {
                 $newEvent = $gdataCal->getEntry($gid, 'Zend_Gdata_Calendar_EventEntry');
             } catch (Exception $e) {
                 // Not found, creating
             }
         }
         if ($newEvent === null) {
             $newEvent = $gdataCal->newEventEntry();
         }
         return $newEvent;
     }
 }

//.........这里部分代码省略.........
                                $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;
    }

/**
 * Creates a recurring 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           $recurData The iCalendar recurring event syntax (RFC2445)
 * @return void
 */
function createRecurringEvent(Zend_Http_Client $client, $title = 'Tennis with Beth', $desc = 'Meet for a quick lesson', $where = 'On the courts', $recurData = null)
{
    $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';
    /**
     * Due to the length of this recurrence syntax, we did not specify
     * it as a default parameter value directly
     */
    if ($recurData == null) {
        $recurData = "DTSTART;VALUE=DATE:20070501\r\n" . "DTEND;VALUE=DATE:20070502\r\n" . "RRULE:FREQ=WEEKLY;BYDAY=Tu;UNTIL=20070904\r\n";
    }
    $newEntry->recurrence = $gc->newRecurrence($recurData);
    $gc->post($newEntry->saveXML());
}

 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();
             }
         }
     }
 }

             $user = query("SELECT * FROM users WHERE id=?", $member["userID"]);
             $user = $user[0];
             $mail->AddAddress($user["number"]);
             // Where to send it
             // send mail
             if ($mail->Send() == false) {
                 die($mail->ErrInfo);
             }
         }
     }
 }
 //$maxPrivacy = query("SELECT MAX(level) FROM privacy")[0]["MAX(level)"];
 $maxPrivacy = $_POST["privacy"];
 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

 function createEvent($client, $title, $desc, $where, $startDate, $startTime, $endDate, $endTime, $tzOffset)
 {
     $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}T{$startTime}:00.000{$tzOffset}:00";
     $when->endTime = "{$endDate}T{$endTime}:00.000{$tzOffset}:00";
     $newEvent->when = array($when);
     $createdEvent = $gdataCal->insertEvent($newEvent);
     return $createdEvent->id->text;
 }

 /**
  * Tarsform  Vtiger Records to Google Records
  * @param <array> $vtEvents 
  * @return <array> tranformed vtiger Records
  */
 public function transformToTargetRecord($vtEvents)
 {
     $records = array();
     foreach ($vtEvents as $vtEvent) {
         $gcalendar = new Zend_Gdata_Calendar($this->apiInstance);
         if ($vtEvent->getMode() == WSAPP_SyncRecordModel::WSAPP_UPDATE_MODE || $vtEvent->getMode() == WSAPP_SyncRecordModel::WSAPP_DELETE_MODE) {
             try {
                 $newEntry = $gcalendar->getCalendarEventEntry($vtEvent->get('_id'));
             } catch (Exception $e) {
                 continue;
             }
         } else {
             $newEntry = $gcalendar->newEventEntry();
         }
         $newEntry->title = $gcalendar->newTitle($vtEvent->get('subject'));
         $newEntry->where = array($gcalendar->newWhere($vtEvent->get('location')));
         $newEntry->content = $gcalendar->newContent($vtEvent->get('description'));
         $newEntry->content->type = 'text';
         $oldtz = date_default_timezone_get();
         date_default_timezone_set('GMT');
         $startDate = $vtEvent->get('date_start');
         $startTime = $vtEvent->get('time_start');
         $endDate = $vtEvent->get('due_date');
         $endTime = $vtEvent->get('time_end');
         if (empty($endTime)) {
             $endTime = "00:00";
         }
         $when = $gcalendar->newWhen();
         $when->startTime = date('c', strtotime("{$startDate} {$startTime}"));
         if (!empty($endDate)) {
             $when->endTime = date('c', strtotime("{$endDate} {$endTime}"));
         }
         date_default_timezone_set($oldtz);
         $newEntry->when = array($when);
         $recordModel = Google_Calendar_Model::getInstanceFromValues(array('entity' => $newEntry));
         $recordModel->setType($this->getSynchronizeController()->getSourceType())->setMode($vtEvent->getMode())->setSyncIdentificationKey($vtEvent->get('_syncidentificationkey'));
         $recordModel = $this->performBasicTransformations($vtEvent, $recordModel);
         $recordModel = $this->performBasicTransformationsToTargetRecords($recordModel, $vtEvent);
         $records[] = $recordModel;
     }
     return $records;
 }