<?php
/*
 * Copyright 2005 - 2013  Zarafa B.V.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License, version 3,
 * as published by the Free Software Foundation with the following additional
 * term according to sec. 7:
 *
 * According to sec. 7 of the GNU Affero General Public License, version
 * 3, the terms of the AGPL are supplemented with the following terms:
 *
 * "Zarafa" is a registered trademark of Zarafa B.V. The licensing of
 * the Program under the AGPL does not imply a trademark license.
 * Therefore any rights, title and interest in our trademarks remain
 * entirely with us.
 *
 * However, if you propagate an unmodified version of the Program you are
 * allowed to use the term "Zarafa" to indicate that you distribute the
 * Program. Furthermore you may use our trademarks where it is necessary
 * to indicate the intended purpose of a product or service provided you
 * use it in accordance with honest practices in industrial or commercial
 * matters.  If you want to propagate modified versions of the Program
 * under the name "Zarafa" or "Zarafa Server", you may only do so if you
 * have a written permission by Zarafa B.V. (to acquire a permission
 * please contact Zarafa at trademark@zarafa.com).
 *
 * The interactive user interface of the software displays an attribution
 * notice containing the term "Zarafa" and/or the logo of Zarafa.
 * Interactive user interfaces of unmodified and modified versions must
 * display Appropriate Legal Notices according to sec. 5 of the GNU
 * Affero General Public License, version 3, when you propagate
 * unmodified or modified versions of the Program. In accordance with
 * sec. 7 b) of the GNU Affero General Public License, version 3, these
 * Appropriate Legal Notices must retain the logo of Zarafa or display
 * the words "Initial Development by Zarafa" if the display of the logo
 * is not reasonably feasible for technical reasons. The use of the logo
 * of Zarafa in Legal Notices is allowed for unmodified and modified
 * versions of the software.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

class Meetingrequest {
    /*
     * NOTE
     *
     * This class is designed to modify and update meeting request properties
     * and to search for linked appointments in the calendar. It does not
     * - set standard properties like subject or location
     * - commit property changes through savechanges() (except in accept() and decline())
     *
     * To set all the other properties, just handle the item as any other appointment
     * item. You aren't even required to set those properties before or after using
     * this class. If you update properties before REsending a meeting request (ie with
     * a time change) you MUST first call updateMeetingRequest() so the internal counters
     * can be updated. You can then submit the message any way you like.
     *
     */

    /*
     * How to use
     * ----------
     *
     * Sending a meeting request:
     * - Create appointment item as normal, but as 'tentative'
     *   (this is the state of the item when the receiving user has received but
     *    not accepted the item)
     * - Set recipients as normally in e-mails
     * - Create Meetingrequest class instance
     * - Call setMeetingRequest(), this turns on all the meeting request properties in the
     *   calendar item
     * - Call sendMeetingRequest(), this sends a copy of the item with some extra properties
     *
     * Updating a meeting request:
     * - Create Meetingrequest class instance
     * - Call updateMeetingRequest(), this updates the counters
     * - Call sendMeetingRequest()
     *
     * Clicking on a an e-mail:
     * - Create Meetingrequest class instance
     * - Check isMeetingRequest(), if true:
     *   - Check isLocalOrganiser(), if true then ignore the message
     *   - Check isInCalendar(), if not call doAccept(true, false, false). This adds the item in your
     *     calendar as tentative without sending a response
     *   - Show Accept, Tentative, Decline buttons
     *   - When the user presses Accept, Tentative or Decline, call doAccept(false, true, true),
     *     doAccept(true, true, true) or doDecline(true) respectively to really accept or decline and
     *     send the response. This will remove the request from your inbox.
     * - Check isMeetingRequestResponse, if true:
     *   - Check isLocalOrganiser(), if not true then ignore the message
     *   - Call processMeetingRequestResponse()
     *     This will update the trackstatus of all recipients, and set the item to 'busy'
     *     when all the recipients have accepted.
     * - Check isMeetingCancellation(), if true:
     *   - Check isLocalOrganiser(), if true then ignore the message
     *   - Check isInCalendar(), if not, then ignore
     *     Call processMeetingCancellation()
     *   - Show 'Remove item' button to user
     *   - When userpresses button, call doCancel(), which removes the item from your
     *     calendar and deletes the message
     */

    // All properties for a recipient that are interesting
    var $recipprops = Array(PR_ENTRYID, PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_RECIPIENT_ENTRYID, PR_RECIPIENT_TYPE, PR_SEND_INTERNET_ENCODING, PR_SEND_RICH_INFO, PR_RECIPIENT_DISPLAY_NAME, PR_ADDRTYPE, PR_DISPLAY_TYPE, PR_RECIPIENT_TRACKSTATUS, PR_RECIPIENT_TRACKSTATUS_TIME, PR_RECIPIENT_FLAGS, PR_ROWID, PR_OBJECT_TYPE, PR_SEARCH_KEY);

    /**
     * Indication whether the setting of resources in a Meeting Request is success (false) or if it
     * has failed (integer).
     */
    var $errorSetResource;

    /**
     * Constructor
     *
     * Takes a store and a message. The message is an appointment item
     * that should be converted into a meeting request or an incoming
     * e-mail message that is a meeting request.
     *
     * The $session variable is optional, but required if the following features
     * are to be used:
     *
     * - Sending meeting requests for meetings that are not in your own store
     * - Sending meeting requests to resources, resource availability checking and resource freebusy updates
     */

    function Meetingrequest($store, $message, $session = false, $enableDirectBooking = true)
    {
        $this->store = $store;
        $this->message = $message;
        $this->session = $session;
        // This variable string saves time information for the MR.
        $this->meetingTimeInfo = false;
        $this->enableDirectBooking = $enableDirectBooking;

        $properties["goid"] = "PT_BINARY:PSETID_Meeting:0x3";
        $properties["goid2"] = "PT_BINARY:PSETID_Meeting:0x23";
        $properties["type"] = "PT_STRING8:PSETID_Meeting:0x24";
        $properties["meetingrecurring"] = "PT_BOOLEAN:PSETID_Meeting:0x5";
        $properties["unknown2"] = "PT_BOOLEAN:PSETID_Meeting:0xa";
        $properties["attendee_critical_change"] = "PT_SYSTIME:PSETID_Meeting:0x1";
        $properties["owner_critical_change"] = "PT_SYSTIME:PSETID_Meeting:0x1a";
        $properties["meetingstatus"] = "PT_LONG:PSETID_Appointment:0x8217";
        $properties["responsestatus"] = "PT_LONG:PSETID_Appointment:0x8218";
        $properties["unknown6"] = "PT_LONG:PSETID_Meeting:0x4";
        $properties["replytime"] = "PT_SYSTIME:PSETID_Appointment:0x8220";
        $properties["usetnef"] = "PT_BOOLEAN:PSETID_Common:0x8582";
        $properties["recurrence_data"] = "PT_BINARY:PSETID_Appointment:0x8216";
        $properties["reminderminutes"] = "PT_LONG:PSETID_Common:0x8501";
        $properties["reminderset"] = "PT_BOOLEAN:PSETID_Common:0x8503";
        $properties["sendasical"] = "PT_BOOLEAN:PSETID_Appointment:0x8200";
        $properties["updatecounter"] = "PT_LONG:PSETID_Appointment:0x8201";                    // AppointmentSequenceNumber
        $properties["last_updatecounter"] = "PT_LONG:PSETID_Appointment:0x8203";            // AppointmentLastSequence
        $properties["unknown7"] = "PT_LONG:PSETID_Appointment:0x8202";
        $properties["busystatus"] = "PT_LONG:PSETID_Appointment:0x8205";
        $properties["intendedbusystatus"] = "PT_LONG:PSETID_Appointment:0x8224";
        $properties["start"] = "PT_SYSTIME:PSETID_Appointment:0x820d";
        $properties["responselocation"] = "PT_STRING8:PSETID_Meeting:0x2";
        $properties["location"] = "PT_STRING8:PSETID_Appointment:0x8208";
        $properties["requestsent"] = "PT_BOOLEAN:PSETID_Appointment:0x8229";        // PidLidFInvited, MeetingRequestWasSent
        $properties["startdate"] = "PT_SYSTIME:PSETID_Appointment:0x820d";
        $properties["duedate"] = "PT_SYSTIME:PSETID_Appointment:0x820e";
        $properties["commonstart"] = "PT_SYSTIME:PSETID_Common:0x8516";
        $properties["commonend"] = "PT_SYSTIME:PSETID_Common:0x8517";
        $properties["recurring"] = "PT_BOOLEAN:PSETID_Appointment:0x8223";
        $properties["clipstart"] = "PT_SYSTIME:PSETID_Appointment:0x8235";
        $properties["clipend"] = "PT_SYSTIME:PSETID_Appointment:0x8236";
        $properties["start_recur_date"] = "PT_LONG:PSETID_Meeting:0xD";                // StartRecurTime
        $properties["start_recur_time"] = "PT_LONG:PSETID_Meeting:0xE";                // StartRecurTime
        $properties["end_recur_date"] = "PT_LONG:PSETID_Meeting:0xF";                // EndRecurDate
        $properties["end_recur_time"] = "PT_LONG:PSETID_Meeting:0x10";                // EndRecurTime
        $properties["is_exception"] = "PT_BOOLEAN:PSETID_Meeting:0xA";                // LID_IS_EXCEPTION
        $properties["apptreplyname"] = "PT_STRING8:PSETID_Appointment:0x8230";
        // Propose new time properties
        $properties["proposed_start_whole"] = "PT_SYSTIME:PSETID_Appointment:0x8250";
        $properties["proposed_end_whole"] = "PT_SYSTIME:PSETID_Appointment:0x8251";
        $properties["proposed_duration"] = "PT_LONG:PSETID_Appointment:0x8256";
        $properties["counter_proposal"] = "PT_BOOLEAN:PSETID_Appointment:0x8257";
        $properties["recurring_pattern"] = "PT_STRING8:PSETID_Appointment:0x8232";
        $properties["basedate"] = "PT_SYSTIME:PSETID_Appointment:0x8228";
        $properties["meetingtype"] = "PT_LONG:PSETID_Meeting:0x26";
        $properties["timezone_data"] = "PT_BINARY:PSETID_Appointment:0x8233";
        $properties["timezone"] = "PT_STRING8:PSETID_Appointment:0x8234";
        $properties["toattendeesstring"] = "PT_STRING8:PSETID_Appointment:0x823B";
        $properties["ccattendeesstring"] = "PT_STRING8:PSETID_Appointment:0x823C";
        $this->proptags = getPropIdsFromStrings($store, $properties);
    }

    /**
     * Sets the direct booking property. This is an alternative to the setting of the direct booking
     * property through the constructor. However, setting it in the constructor is prefered.
     * @param Boolean $directBookingSetting
     *
     */
    function setDirectBooking($directBookingSetting)
    {
        $this->enableDirectBooking = $directBookingSetting;
    }

    /**
     * Returns TRUE if the message pointed to is an incoming meeting request and should
     * therefore be replied to with doAccept or doDecline()
     */
    function isMeetingRequest()
    {
        $props = mapi_getprops($this->message, Array(PR_MESSAGE_CLASS));

        if(isset($props[PR_MESSAGE_CLASS]) && $props[PR_MESSAGE_CLASS] == "IPM.Schedule.Meeting.Request")
            return true;
    }

    /**
     * Returns TRUE if the message pointed to is a returning meeting request response
     */
    function isMeetingRequestResponse()
    {
        $props = mapi_getprops($this->message, Array(PR_MESSAGE_CLASS));

        if(isset($props[PR_MESSAGE_CLASS]) && strpos($props[PR_MESSAGE_CLASS], "IPM.Schedule.Meeting.Resp") === 0)
            return true;
    }

    /**
     * Returns TRUE if the message pointed to is a cancellation request
     */
    function isMeetingCancellation()
    {
        $props = mapi_getprops($this->message, Array(PR_MESSAGE_CLASS));

        if(isset($props[PR_MESSAGE_CLASS]) && $props[PR_MESSAGE_CLASS] == "IPM.Schedule.Meeting.Canceled")
            return true;
    }


    /**
     * Process an incoming meeting request response as Delegate. This will updates the appointment
     * in Organiser's calendar.
     * @returns the entryids(storeid, parententryid, entryid, also basedate if response is occurrence)
     * of corresponding meeting in Calendar
     */
    function processMeetingRequestResponseAsDelegate()
    {
        if(!$this->isMeetingRequestResponse())
            return;

        $messageprops = mapi_getprops($this->message);

        $goid2 = $messageprops[$this->proptags['goid2']];

        if(!isset($goid2) || !isset($messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS]))
            return;

        // Find basedate in GlobalID(0x3), this can be a response for an occurrence
        $basedate = $this->getBasedateFromGlobalID($messageprops[$this->proptags['goid']]);

        if (isset($messageprops[PR_RCVD_REPRESENTING_NAME])) {
            $delegatorStore = $this->getDelegatorStore($messageprops);
            $userStore = $delegatorStore['store'];
            $calFolder = $delegatorStore['calFolder'];

            if($calFolder){
                $calendaritems = $this->findCalendarItems($goid2, $calFolder);

                // $calendaritems now contains the ENTRYID's of all the calendar items to which
                // this meeting request points.

                // Open the calendar items, and update all the recipients of the calendar item that match
                // the email address of the response.
                if (!empty($calendaritems)) {
                     return $this->processResponse($userStore, $calendaritems[0], $basedate, $messageprops);
                }else{
                    return false;
                }
            }
        }
    }


    /**
     * Process an incoming meeting request response. This updates the appointment
     * in your calendar to show whether the user has accepted or declined.
     * @returns the entryids(storeid, parententryid, entryid, also basedate if response is occurrence)
     * of corresponding meeting in Calendar
     */
    function processMeetingRequestResponse()
    {
        if(!$this->isLocalOrganiser())
            return;

        if(!$this->isMeetingRequestResponse())
            return;

        // Get information we need from the response message
        $messageprops = mapi_getprops($this->message, Array(
                                                    $this->proptags['goid'],
                                                    $this->proptags['goid2'],
                                                    PR_OWNER_APPT_ID,
                                                    PR_SENT_REPRESENTING_EMAIL_ADDRESS,
                                                    PR_SENT_REPRESENTING_NAME,
                                                    PR_SENT_REPRESENTING_ADDRTYPE,
                                                    PR_SENT_REPRESENTING_ENTRYID,
                                                    PR_MESSAGE_DELIVERY_TIME,
                                                    PR_MESSAGE_CLASS,
                                                    PR_PROCESSED,
                                                    $this->proptags['proposed_start_whole'],
                                                    $this->proptags['proposed_end_whole'],
                                                    $this->proptags['proposed_duration'],
                                                    $this->proptags['counter_proposal'],
                                                    $this->proptags['attendee_critical_change']));

        $goid2 = $messageprops[$this->proptags['goid2']];

        if(!isset($goid2) || !isset($messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS]))
            return;

        // Find basedate in GlobalID(0x3), this can be a response for an occurrence
        $basedate = $this->getBasedateFromGlobalID($messageprops[$this->proptags['goid']]);

        $calendaritems = $this->findCalendarItems($goid2);

        // $calendaritems now contains the ENTRYID's of all the calendar items to which
        // this meeting request points.

        // Open the calendar items, and update all the recipients of the calendar item that match
        // the email address of the response.
        if (!empty($calendaritems)) {
            return $this->processResponse($this->store, $calendaritems[0], $basedate, $messageprops);
        }else{
            return false;
        }
    }

    /**
     * Process every incoming MeetingRequest response.This updates the appointment
     * in your calendar to show whether the user has accepted or declined.
     *@param resource $store contains the userStore in which the meeting is created
     *@param $entryid contains the ENTRYID of the calendar items to which this meeting request points.
     *@param boolean $basedate if present the create an exception
     *@param array $messageprops contains m3/17/2010essage properties.
     *@return entryids(storeid, parententryid, entryid, also basedate if response is occurrence) of corresponding meeting in Calendar
     */
    function processResponse($store, $entryid, $basedate, $messageprops)
    {
        $data = array();
        $senderentryid = $messageprops[PR_SENT_REPRESENTING_ENTRYID];
        $messageclass = $messageprops[PR_MESSAGE_CLASS];
        $deliverytime = $messageprops[PR_MESSAGE_DELIVERY_TIME];

        // Open the calendar item, find the sender in the recipient table and update all the recipients of the calendar item that match
        // the email address of the response.
        $calendaritem = mapi_msgstore_openentry($store, $entryid);
        $calendaritemProps = mapi_getprops($calendaritem, array($this->proptags['recurring'], PR_STORE_ENTRYID, PR_PARENT_ENTRYID, PR_ENTRYID, $this->proptags['updatecounter']));

        $data["storeid"] = bin2hex($calendaritemProps[PR_STORE_ENTRYID]);
        $data["parententryid"] = bin2hex($calendaritemProps[PR_PARENT_ENTRYID]);
        $data["entryid"] = bin2hex($calendaritemProps[PR_ENTRYID]);
        $data["basedate"] = $basedate;
        $data["updatecounter"] = isset($calendaritemProps[$this->proptags['updatecounter']]) ? $calendaritemProps[$this->proptags['updatecounter']] : 0;

        /**
         * Check if meeting is updated or not in organizer's calendar
         */
        $data["meeting_updated"] = $this->isMeetingUpdated();

        if(isset($messageprops[PR_PROCESSED]) && $messageprops[PR_PROCESSED] == true) {
            // meeting is already processed
            return $data;
        } else {
            mapi_setprops($this->message, Array(PR_PROCESSED => true));
            mapi_savechanges($this->message);
        }

        // if meeting is updated in organizer's calendar then we don't need to process
        // old response
        if($data['meeting_updated'] === true) {
            return $data;
        }

        // If basedate is found, then create/modify exception msg and do processing
        if ($basedate && $calendaritemProps[$this->proptags['recurring']]) {
            $recurr = new Recurrence($store, $calendaritem);

            // Copy properties from meeting request
            $exception_props = mapi_getprops($this->message, array(PR_OWNER_APPT_ID,
                                                $this->proptags['proposed_start_whole'],
                                                $this->proptags['proposed_end_whole'],
                                                $this->proptags['proposed_duration'],
                                                $this->proptags['counter_proposal']
                                            ));

            // Create/modify exception
            if($recurr->isException($basedate)) {
                $recurr->modifyException($exception_props, $basedate);
            } else {
                // When we are creating an exception we need copy recipients from main recurring item
                $recipTable =  mapi_message_getrecipienttable($calendaritem);
                $recips = mapi_table_queryallrows($recipTable, $this->recipprops);

                // Retrieve actual start/due dates from calendar item.
                $exception_props[$this->proptags['startdate']] = $recurr->getOccurrenceStart($basedate);
                $exception_props[$this->proptags['duedate']] = $recurr->getOccurrenceEnd($basedate);

                $recurr->createException($exception_props, $basedate, false, $recips);
            }

            mapi_message_savechanges($calendaritem);

            $attach = $recurr->getExceptionAttachment($basedate);
            if ($attach) {
                $recurringItem = $calendaritem;
                $calendaritem = mapi_attach_openobj($attach, MAPI_MODIFY);
            } else {
                return false;
            }
        }

        // Get the recipients of the calendar item
        $reciptable = mapi_message_getrecipienttable($calendaritem);
        $recipients = mapi_table_queryallrows($reciptable, $this->recipprops);

        // FIXME we should look at the updatecounter property and compare it
        // to the counter in the recipient to see if this update is actually
        // newer than the status in the calendar item
        $found = false;

        $totalrecips = 0;
        $acceptedrecips = 0;
        foreach($recipients as $recipient) {
            $totalrecips++;
            if(isset($recipient[PR_ENTRYID]) && $this->compareABEntryIDs($recipient[PR_ENTRYID],$senderentryid)) {
                $found = true;

                /**
                 * If value of attendee_critical_change on meeting response mail is less than PR_RECIPIENT_TRACKSTATUS_TIME
                 * on the corresponding recipientRow of meeting then we ignore this response mail.
                 */
                if (isset($recipient[PR_RECIPIENT_TRACKSTATUS_TIME]) && ($messageprops[$this->proptags['attendee_critical_change']] < $recipient[PR_RECIPIENT_TRACKSTATUS_TIME])) {
                    continue;
                }

                // The email address matches, update the row
                $recipient[PR_RECIPIENT_TRACKSTATUS] = $this->getTrackStatus($messageclass);
                $recipient[PR_RECIPIENT_TRACKSTATUS_TIME] = $messageprops[$this->proptags['attendee_critical_change']];

                // If this is a counter proposal, set the proposal properties in the recipient row
                if(isset($messageprops[$this->proptags['counter_proposal']]) && $messageprops[$this->proptags['counter_proposal']]){
                    $recipient[PR_PROPOSENEWTIME_START] = $messageprops[$this->proptags['proposed_start_whole']];
                    $recipient[PR_PROPOSENEWTIME_END] = $messageprops[$this->proptags['proposed_end_whole']];
                    $recipient[PR_PROPOSEDNEWTIME] = $messageprops[$this->proptags['counter_proposal']];
                }

                mapi_message_modifyrecipients($calendaritem, MODRECIP_MODIFY, Array($recipient));
            }
            if(isset($recipient[PR_RECIPIENT_TRACKSTATUS]) && $recipient[PR_RECIPIENT_TRACKSTATUS] == olRecipientTrackStatusAccepted)
                $acceptedrecips++;
        }

        // If the recipient was not found in the original calendar item,
        // then add the recpient as a new optional recipient
        if(!$found) {
            $recipient = Array();
            $recipient[PR_ENTRYID] = $messageprops[PR_SENT_REPRESENTING_ENTRYID];
            $recipient[PR_EMAIL_ADDRESS] = $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
            $recipient[PR_DISPLAY_NAME] = $messageprops[PR_SENT_REPRESENTING_NAME];
            $recipient[PR_ADDRTYPE] = $messageprops[PR_SENT_REPRESENTING_ADDRTYPE];
            $recipient[PR_RECIPIENT_TYPE] = MAPI_CC;
            $recipient[PR_RECIPIENT_TRACKSTATUS] = $this->getTrackStatus($messageclass);
            $recipient[PR_RECIPIENT_TRACKSTATUS_TIME] = $deliverytime;

            // If this is a counter proposal, set the proposal properties in the recipient row
            if(isset($messageprops[$this->proptags['counter_proposal']])){
                $recipient[PR_PROPOSENEWTIME_START] = $messageprops[$this->proptags['proposed_start_whole']];
                $recipient[PR_PROPOSENEWTIME_END] = $messageprops[$this->proptags['proposed_end_whole']];
                $recipient[PR_PROPOSEDNEWTIME] = $messageprops[$this->proptags['counter_proposal']];
            }

            mapi_message_modifyrecipients($calendaritem, MODRECIP_ADD, Array($recipient));
            $totalrecips++;
            if($recipient[PR_RECIPIENT_TRACKSTATUS] == olRecipientTrackStatusAccepted)
                $acceptedrecips++;
        }

//TODO: Upate counter proposal number property on message
/*
If it is the first time this attendee has proposed a new date/time, increment the value of the PidLidAppointmentProposalNumber property on the organizer�s meeting object, by 0x00000001. If this property did not previously exist on the organizer�s meeting object, it MUST be set with a value of 0x00000001.
*/
        // If this is a counter proposal, set the counter proposal indicator boolean
        if(isset($messageprops[$this->proptags['counter_proposal']])){
            $props = Array();
            if($messageprops[$this->proptags['counter_proposal']]){
                $props[$this->proptags['counter_proposal']] = true;
            }else{
                $props[$this->proptags['counter_proposal']] = false;
            }

            mapi_message_setprops($calendaritem, $props);
        }

        mapi_message_savechanges($calendaritem);
        if (isset($attach)) {
            mapi_message_savechanges($attach);
            mapi_message_savechanges($recurringItem);
        }

        return $data;
    }


    /**
     * Process an incoming meeting request cancellation. This updates the
     * appointment in your calendar to show that the meeting has been cancelled.
     */
    function processMeetingCancellation()
    {
        if($this->isLocalOrganiser())
            return;

        if(!$this->isMeetingCancellation())
            return;

        if(!$this->isInCalendar())
            return;

        $listProperties = $this->proptags;
        $listProperties['subject'] = PR_SUBJECT;
        $listProperties['sent_representing_name'] = PR_SENT_REPRESENTING_NAME;
        $listProperties['sent_representing_address_type'] = PR_SENT_REPRESENTING_ADDRTYPE;
        $listProperties['sent_representing_email_address'] = PR_SENT_REPRESENTING_EMAIL_ADDRESS;
        $listProperties['sent_representing_entryid'] = PR_SENT_REPRESENTING_ENTRYID;
        $listProperties['sent_representing_search_key'] = PR_SENT_REPRESENTING_SEARCH_KEY;
        $listProperties['rcvd_representing_name'] = PR_RCVD_REPRESENTING_NAME;
        $messageprops = mapi_getprops($this->message, $listProperties);
        $store = $this->store;

        $goid = $messageprops[$this->proptags['goid']];    //GlobalID (0x3)
        if(!isset($goid))
            return;

        if (isset($messageprops[PR_RCVD_REPRESENTING_NAME])){
            $delegatorStore = $this->getDelegatorStore($messageprops);
            $store = $delegatorStore['store'];
            $calFolder = $delegatorStore['calFolder'];
        } else {
            $calFolder = $this->openDefaultCalendar();
        }

        // First, find the items in the calendar by GOID
        $calendaritems = $this->findCalendarItems($goid, $calFolder);
        $basedate = $this->getBasedateFromGlobalID($goid);

        if ($basedate) {
            // Calendaritems with GlobalID were not found, so find main recurring item using CleanGlobalID(0x23)
            if (empty($calendaritems)) {
                // This meeting req is of an occurrance
                $goid2 = $messageprops[$this->proptags['goid2']];

                // First, find the items in the calendar by GOID
                $calendaritems = $this->findCalendarItems($goid2);
                foreach($calendaritems as $entryid) {
                    // Open each calendar item and set the properties of the cancellation object
                    $calendaritem = mapi_msgstore_openentry($store, $entryid);

                    if ($calendaritem){
                        $calendaritemProps = mapi_getprops($calendaritem, array($this->proptags['recurring']));
                        if ($calendaritemProps[$this->proptags['recurring']]){
                            $recurr = new Recurrence($store, $calendaritem);

                            // Set message class
                            $messageprops[PR_MESSAGE_CLASS] = 'IPM.Appointment';

                            if($recurr->isException($basedate))
                                $recurr->modifyException($messageprops, $basedate);
                            else
                                $recurr->createException($messageprops, $basedate);
                        }
                        mapi_savechanges($calendaritem);
                    }
                }
            }
        }

        if (!isset($calendaritem)) {
            foreach($calendaritems as $entryid) {
                // Open each calendar item and set the properties of the cancellation object
                $calendaritem = mapi_msgstore_openentry($store, $entryid);
                mapi_message_setprops($calendaritem, $messageprops);
                mapi_savechanges($calendaritem);
            }
        }
    }

    /**
     * Returns true if the item is already in the calendar
     */
    function isInCalendar() {
        $messageprops = mapi_getprops($this->message, Array($this->proptags['goid'], $this->proptags['goid2'], PR_RCVD_REPRESENTING_NAME));
        $goid = $messageprops[$this->proptags['goid']];
        if (isset($messageprops[$this->proptags['goid2']]))
            $goid2 = $messageprops[$this->proptags['goid2']];

        $basedate = $this->getBasedateFromGlobalID($goid);

        if (isset($messageprops[PR_RCVD_REPRESENTING_NAME])){
            $delegatorStore = $this->getDelegatorStore($messageprops);
            $calFolder = $delegatorStore['calFolder'];
        } else {
            $calFolder = $this->openDefaultCalendar();
        }
        /**
         * If basedate is found in globalID, then there are two possibilities.
         * case 1) User has only this occurrence OR
         * case 2) User has recurring item and has received an update for an occurrence
         */
        if ($basedate) {
            // First try with GlobalID(0x3) (case 1)
            $entryid = $this->findCalendarItems($goid, $calFolder);
            // If not found then try with CleanGlobalID(0x23) (case 2)
            if (!is_array($entryid) && isset($goid2))
                $entryid = $this->findCalendarItems($goid2, $calFolder);
        } else if (isset($goid2)) {
            $entryid = $this->findCalendarItems($goid2, $calFolder);
        }
        else
            return false;

        return is_array($entryid);
    }

    /**
     * Accepts the meeting request by moving the item to the calendar
     * and sending a confirmation message back to the sender. If $tentative
     * is TRUE, then the item is accepted tentatively. After accepting, you
     * can't use this class instance any more. The message is closed. If you
     * specify TRUE for 'move', then the item is actually moved (from your
     * inbox probably) to the calendar. If you don't, it is copied into
     * your calendar.
     *@param boolean $tentative true if user as tentative accepted the meeting
     *@param boolean $sendresponse true if a response has to be send to organizer
     *@param boolean $move true if the meeting request should be moved to the deleted items after processing
     *@param string $newProposedStartTime contains starttime if user has proposed other time
     *@param string $newProposedEndTime contains endtime if user has proposed other time
     *@param string $basedate start of day of occurrence for which user has accepted the recurrent meeting
     *@return string $entryid entryid of item which created/updated in calendar
     */
    function doAccept($tentative, $sendresponse, $move, $newProposedStartTime=false, $newProposedEndTime=false, $body=false, $userAction = false, $store=false, $basedate = false)
    {
        if($this->isLocalOrganiser())
            return false;

        // Remove any previous calendar items with this goid and appt id
        $messageprops = mapi_getprops($this->message, Array(PR_ENTRYID, PR_MESSAGE_CLASS, $this->proptags['goid'], $this->proptags['goid2'], PR_OWNER_APPT_ID, $this->proptags['updatecounter'], PR_PROCESSED, $this->proptags['recurring'], $this->proptags['intendedbusystatus'], PR_RCVD_REPRESENTING_NAME));

        /**
         *    if this function is called automatically with meeting request object then there will be
         *    two possibilitites
         *    1) meeting request is opened first time, in this case make a tentative appointment in
                recipient's calendar
         *    2) after this every subsequest request to open meeting request will not do any processing
         */
        if($messageprops[PR_MESSAGE_CLASS] == "IPM.Schedule.Meeting.Request" && $userAction == false) {
            if(isset($messageprops[PR_PROCESSED]) && $messageprops[PR_PROCESSED] == true) {
                // if meeting request is already processed then don't do anything
                return false;
            } else {
                mapi_setprops($this->message, Array(PR_PROCESSED => true));
                mapi_message_savechanges($this->message);
            }
        }

        // If this meeting request is received by a delegate then open delegator's store.
        if (isset($messageprops[PR_RCVD_REPRESENTING_NAME])) {
            $delegatorStore = $this->getDelegatorStore($messageprops);

            $store = $delegatorStore['store'];
            $calFolder = $delegatorStore['calFolder'];
        } else {
            $calFolder = $this->openDefaultCalendar();
            $store = $this->store;
        }

        return $this->accept($tentative, $sendresponse, $move, $newProposedStartTime, $newProposedEndTime, $body, $userAction, $store, $calFolder, $basedate);
    }

    function accept($tentative, $sendresponse, $move, $newProposedStartTime=false, $newProposedEndTime=false, $body=false, $userAction = false, $store, $calFolder, $basedate = false)
    {
        $messageprops = mapi_getprops($this->message);
        $isDelegate = false;

        if (isset($messageprops[PR_DELEGATED_BY_RULE]))
            $isDelegate = true;

        $goid = $messageprops[$this->proptags['goid2']];

        // Retrieve basedate from globalID, if it is not recieved as argument
        if (!$basedate)
            $basedate = $this->getBasedateFromGlobalID($messageprops[$this->proptags['goid']]);

        if ($sendresponse)
            $this->createResponse($tentative ? olResponseTentative : olResponseAccepted, $newProposedStartTime, $newProposedEndTime, $body, $store, $basedate, $calFolder);

        $entryids = $this->findCalendarItems($goid, $calFolder);

        if(is_array($entryids)) {
            // Only check the first, there should only be one anyway...
            $previtem = mapi_msgstore_openentry($store, $entryids[0]);
            $prevcounterprops = mapi_getprops($previtem, array($this->proptags['updatecounter']));

            // Check if the existing item has an updatecounter that is lower than the request we are processing. If not, then we ignore this call, since the
            // meeting request is out of date.
            /*
                if(message_counter < appointment_counter) do_nothing
                if(message_counter == appointment_counter) do_something_if_the_user_tells_us (userAction == true)
                if(message_counter > appointment_counter) do_something_even_automatically
            */
            if(isset($prevcounterprops[$this->proptags['updatecounter']]) && $messageprops[$this->proptags['updatecounter']] < $prevcounterprops[$this->proptags['updatecounter']]) {
                return false;
            } else if(isset($prevcounterprops[$this->proptags['updatecounter']]) && $messageprops[$this->proptags['updatecounter']] == $prevcounterprops[$this->proptags['updatecounter']]) {
                if($userAction == false && !$basedate) {
                    return false;
                }
            }
        }

        // set counter proposal properties in calendar item when proposing new time
        // @FIXME this can be moved before call to createResponse function so that function doesn't need to recalculate duration
        $proposeNewTimeProps = array();
        if($newProposedStartTime && $newProposedEndTime) {
            $proposeNewTimeProps[$this->proptags['proposed_start_whole']] = $newProposedStartTime;
            $proposeNewTimeProps[$this->proptags['proposed_end_whole']] = $newProposedEndTime;
            $proposeNewTimeProps[$this->proptags['proposed_duration']] = round($newProposedEndTime - $newProposedStartTime) / 60;
            $proposeNewTimeProps[$this->proptags['counter_proposal']] = true;
        }

        /**
         * Further processing depends on what user is receiving. User can receive recurring item, a single occurrence or a normal meeting.
         * 1) If meeting req is of recurrence then we find all the occurrence in calendar because in past user might have recivied one or few occurrences.
         * 2) If single occurrence then find occurrence itself using globalID and if item is not found then user cleanGlobalID to find main recurring item
         * 3) Normal meeting req are handled normally has they were handled previously.
         *
         * Also user can respond(accept/decline) to item either from previewpane or from calendar by opening the item. If user is responding the meeting from previewpane
         * and that item is not found in calendar then item is move else item is opened and all properties, attachments and recipient are copied from meeting request.
         * If user is responding from calendar then item is opened and properties are set such as meetingstatus, responsestatus, busystatus etc.
         */
        if ($messageprops[PR_MESSAGE_CLASS] == "IPM.Schedule.Meeting.Request") {
            // While processing the item mark it as read.
            mapi_message_setreadflag($this->message, SUPPRESS_RECEIPT);

            // This meeting request item is recurring, so find all occurrences and saves them all as exceptions to this meeting request item.
            if ($messageprops[$this->proptags['recurring']] == true) {
                $calendarItem = false;

                // Find main recurring item based on GlobalID (0x3)
                $items = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder);
                if (is_array($items)) {
                    foreach($items as $key => $entryid)
                        $calendarItem = mapi_msgstore_openentry($store, $entryid);
                }

                // Recurring item not found, so create new meeting in Calendar
                if (!$calendarItem)
                    $calendarItem = mapi_folder_createmessage($calFolder);

                // Copy properties
                $props = mapi_getprops($this->message);
                $props[PR_MESSAGE_CLASS] = 'IPM.Appointment';
                $props[$this->proptags['meetingstatus']] = olMeetingReceived;
                // when we are automatically processing the meeting request set responsestatus to olResponseNotResponded
                $props[$this->proptags['responsestatus']] = $userAction ? ($tentative ? olResponseTentative : olResponseAccepted) : olResponseNotResponded;

                if (isset($props[$this->proptags['intendedbusystatus']])) {
                    if($tentative && $props[$this->proptags['intendedbusystatus']] !== fbFree) {
                        $props[$this->proptags['busystatus']] = $tentative;
                    } else {
                        $props[$this->proptags['busystatus']] = $props[$this->proptags['intendedbusystatus']];
                    }
                    // we already have intendedbusystatus value in $props so no need to copy it
                } else {
                    $props[$this->proptags['busystatus']] = $tentative ? fbTentative : fbBusy;
                }

                if($userAction) {
                    // if user has responded then set replytime
                    $props[$this->proptags['replytime']] = time();
                }

                mapi_setprops($calendarItem, $props);

                // Copy attachments too
                $this->replaceAttachments($this->message, $calendarItem);
                // Copy recipients too
                $this->replaceRecipients($this->message, $calendarItem, $isDelegate);

                // Find all occurrences based on CleanGlobalID (0x23)
                $items = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder, true);
                if (is_array($items)) {
                    // Save all existing occurrence as exceptions
                    foreach($items as $entryid) {
                        // Open occurrence
                        $occurrenceItem = mapi_msgstore_openentry($store, $entryid);

                        // Save occurrence into main recurring item as exception
                        if ($occurrenceItem) {
                            $occurrenceItemProps = mapi_getprops($occurrenceItem, array($this->proptags['goid'], $this->proptags['recurring']));

                            // Find basedate of occurrence item
                            $basedate = $this->getBasedateFromGlobalID($occurrenceItemProps[$this->proptags['goid']]);
                            if ($basedate && $occurrenceItemProps[$this->proptags['recurring']] != true)
                                $this->acceptException($calendarItem, $occurrenceItem, $basedate, true, $tentative, $userAction, $store, $isDelegate);
                        }
                    }
                }
                mapi_savechanges($calendarItem);
                if ($move) {
                    $wastebasket = $this->openDefaultWastebasket();
                    mapi_folder_copymessages($calFolder, Array($props[PR_ENTRYID]), $wastebasket, MESSAGE_MOVE);
                }
                $entryid = $props[PR_ENTRYID];
            } else {
                /**
                 * This meeting request is not recurring, so can be an exception or normal meeting.
                 * If exception then find main recurring item and update exception
                 * If main recurring item is not found then put exception into Calendar as normal meeting.
                 */
                $calendarItem = false;

                // We found basedate in GlobalID of this meeting request, so this meeting request if for an occurrence.
                if ($basedate) {
                    // Find main recurring item from CleanGlobalID of this meeting request
                    $items = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder);
                    if (is_array($items)) {
                        foreach($items as $key => $entryid) {
                            $calendarItem = mapi_msgstore_openentry($store, $entryid);
                        }
                    }

                    // Main recurring item is found, so now update exception
                    if ($calendarItem) {
                        $this->acceptException($calendarItem, $this->message, $basedate, $move, $tentative, $userAction, $store, $isDelegate);
                        $calendarItemProps = mapi_getprops($calendarItem, array(PR_ENTRYID));
                        $entryid = $calendarItemProps[PR_ENTRYID];
                    }
                }

                if (!$calendarItem) {
                    $items = $this->findCalendarItems($messageprops[$this->proptags['goid']], $calFolder);

                    if (is_array($items))
                        mapi_folder_deletemessages($calFolder, $items);

                    if ($move) {
                        // All we have to do is open the default calendar,
                        // set the mesage class correctly to be an appointment item
                        // and move it to the calendar folder
                        $sourcefolder = $this->openParentFolder();

                        /* create a new calendar message, and copy the message to there,
                           since we want to delete (move to wastebasket) the original message */
                        $old_entryid = mapi_getprops($this->message, Array(PR_ENTRYID));
                        $calmsg = mapi_folder_createmessage($calFolder);
                        mapi_copyto($this->message, array(), array(), $calmsg); /* includes attachments and recipients */
                        /* release old message */
                        $message = null;

                        $calItemProps = Array();
                        $calItemProps[PR_MESSAGE_CLASS] = "IPM.Appointment";

                        if (isset($messageprops[$this->proptags['intendedbusystatus']])) {
                            if($tentative && $messageprops[$this->proptags['intendedbusystatus']] !== fbFree) {
                                $calItemProps[$this->proptags['busystatus']] = $tentative;
                            } else {
                                $calItemProps[$this->proptags['busystatus']] = $messageprops[$this->proptags['intendedbusystatus']];
                            }
                            $calItemProps[$this->proptags['intendedbusystatus']] = $messageprops[$this->proptags['intendedbusystatus']];
                        } else {
                            $calItemProps[$this->proptags['busystatus']] = $tentative ? fbTentative : fbBusy;
                        }

                        // when we are automatically processing the meeting request set responsestatus to olResponseNotResponded
                        $calItemProps[$this->proptags['responsestatus']] = $userAction ? ($tentative ? olResponseTentative : olResponseAccepted) : olResponseNotResponded;
                        if($userAction) {
                            // if user has responded then set replytime
                            $calItemProps[$this->proptags['replytime']] = time();
                        }

                        mapi_setprops($calmsg, $proposeNewTimeProps + $calItemProps);

                        // get properties which stores owner information in meeting request mails
                        $props = mapi_getprops($calmsg, array(PR_SENT_REPRESENTING_ENTRYID, PR_SENT_REPRESENTING_NAME, PR_SENT_REPRESENTING_EMAIL_ADDRESS, PR_SENT_REPRESENTING_ADDRTYPE));

                        // add owner to recipient table
                        $recips = array();
                        $this->addOrganizer($props, $recips);

                        if($isDelegate) {
                            /**
                             * If user is delegate then remove that user from recipienttable of the MR.
                             * and delegate MR mail doesn't contain any of the attendees in recipient table.
                             * So, other required and optional attendees are added from
                             * toattendeesstring and ccattendeesstring properties.
                             */
                            $this->setRecipsFromString($recips, $messageprops[$this->proptags['toattendeesstring']], MAPI_TO);
                            $this->setRecipsFromString($recips, $messageprops[$this->proptags['ccattendeesstring']], MAPI_CC);
                            mapi_message_modifyrecipients($calmsg, 0, $recips);
                        } else {
                            mapi_message_modifyrecipients($calmsg, MODRECIP_ADD, $recips);
                        }

                        mapi_message_savechanges($calmsg);

                        // Move the message to the wastebasket
                        $wastebasket = $this->openDefaultWastebasket();
                        mapi_folder_copymessages($sourcefolder, array($old_entryid[PR_ENTRYID]), $wastebasket, MESSAGE_MOVE);

                        $messageprops = mapi_getprops($calmsg, array(PR_ENTRYID));
                        $entryid = $messageprops[PR_ENTRYID];
                    } else {
                        // Create a new appointment with duplicate properties and recipient, but as an IPM.Appointment
                        $new = mapi_folder_createmessage($calFolder);
                        $props = mapi_getprops($this->message);

                        $props[PR_MESSAGE_CLASS] = "IPM.Appointment";
                        // when we are automatically processing the meeting request set responsestatus to olResponseNotResponded
                        $props[$this->proptags['responsestatus']] = $userAction ? ($tentative ? olResponseTentative : olResponseAccepted) : olResponseNotResponded;

                        if (isset($props[$this->proptags['intendedbusystatus']])) {
                            if($tentative && $props[$this->proptags['intendedbusystatus']] !== fbFree) {
                                $props[$this->proptags['busystatus']] = $tentative;
                            } else {
                                $props[$this->proptags['busystatus']] = $props[$this->proptags['intendedbusystatus']];
                            }
                            // we already have intendedbusystatus value in $props so no need to copy it
                        } else {
                            $props[$this->proptags['busystatus']] = $tentative ? fbTentative : fbBusy;
                        }

                        // ZP-341 - we need to copy as well the attachments
                        // Copy attachments too
                        $this->replaceAttachments($this->message, $new);
                        // ZP-341 - end

                        if($userAction) {
                            // if user has responded then set replytime
                            $props[$this->proptags['replytime']] = time();
                        }

                        mapi_setprops($new, $proposeNewTimeProps + $props);

                        $reciptable = mapi_message_getrecipienttable($this->message);

                        $recips = array();
                        if(!$isDelegate)
                            $recips = mapi_table_queryallrows($reciptable, $this->recipprops);

                        $this->addOrganizer($props, $recips);

                        if($isDelegate) {
                            /**
                             * If user is delegate then remove that user from recipienttable of the MR.
                             * and delegate MR mail doesn't contain any of the attendees in recipient table.
                             * So, other required and optional attendees are added from
                             * toattendeesstring and ccattendeesstring properties.
                             */
                            $this->setRecipsFromString($recips, $messageprops[$this->proptags['toattendeesstring']], MAPI_TO);
                            $this->setRecipsFromString($recips, $messageprops[$this->proptags['ccattendeesstring']], MAPI_CC);
                            mapi_message_modifyrecipients($new, 0, $recips);
                        } else {
                            mapi_message_modifyrecipients($new, MODRECIP_ADD, $recips);
                        }
                        mapi_message_savechanges($new);

                        $props = mapi_getprops($new, array(PR_ENTRYID));
                        $entryid = $props[PR_ENTRYID];
                    }
                }
            }
        } else {
            // Here only properties are set on calendaritem, because user is responding from calendar.
            $props = array();
            $props[$this->proptags['responsestatus']] = $tentative ? olResponseTentative : olResponseAccepted;

            if (isset($messageprops[$this->proptags['intendedbusystatus']])) {
                if($tentative && $messageprops[$this->proptags['intendedbusystatus']] !== fbFree) {
                    $props[$this->proptags['busystatus']] = $tentative;
                } else {
                    $props[$this->proptags['busystatus']] = $messageprops[$this->proptags['intendedbusystatus']];
                }
                $props[$this->proptags['intendedbusystatus']] = $messageprops[$this->proptags['intendedbusystatus']];
            } else {
                $props[$this->proptags['busystatus']] = $tentative ? fbTentative : fbBusy;
            }

            $props[$this->proptags['meetingstatus']] = olMeetingReceived;
            $props[$this->proptags['replytime']] = time();

            if ($basedate) {
                $recurr = new Recurrence($store, $this->message);

                // Copy recipients list
                $reciptable = mapi_message_getrecipienttable($this->message);
                $recips = mapi_table_queryallrows($reciptable, $this->recipprops);

                if($recurr->isException($basedate)) {
                    $recurr->modifyException($proposeNewTimeProps + $props, $basedate, $recips);
                } else {
                    $props[$this->proptags['startdate']] = $recurr->getOccurrenceStart($basedate);
                    $props[$this->proptags['duedate']] = $recurr->getOccurrenceEnd($basedate);

                    $props[PR_SENT_REPRESENTING_EMAIL_ADDRESS] = $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
                    $props[PR_SENT_REPRESENTING_NAME] = $messageprops[PR_SENT_REPRESENTING_NAME];
                    $props[PR_SENT_REPRESENTING_ADDRTYPE] = $messageprops[PR_SENT_REPRESENTING_ADDRTYPE];
                    $props[PR_SENT_REPRESENTING_ENTRYID] = $messageprops[PR_SENT_REPRESENTING_ENTRYID];

                    $recurr->createException($proposeNewTimeProps + $props, $basedate, false, $recips);
                }
            } else {
                mapi_setprops($this->message, $proposeNewTimeProps + $props);
            }
            mapi_savechanges($this->message);

            $entryid = $messageprops[PR_ENTRYID];
        }

        return $entryid;
    }

    /**
     * Declines the meeting request by moving the item to the deleted
     * items folder and sending a decline message. After declining, you
     * can't use this class instance any more. The message is closed.
     * When an occurrence is decline then false is returned because that
     * occurrence is deleted not the recurring item.
     *
     *@param boolean $sendresponse true if a response has to be sent to organizer
     *@param resource $store MAPI_store of user
     *@param string $basedate if specified contains starttime of day of an occurrence
     *@return boolean true if item is deleted from Calendar else false
     */
    function doDecline($sendresponse, $store=false, $basedate = false, $body = false)
    {
        $result = true;
        $calendaritem = false;
        if($this->isLocalOrganiser())
            return;

        // Remove any previous calendar items with this goid and appt id
        $messageprops = mapi_getprops($this->message, Array($this->proptags['goid'], $this->proptags['goid2'], PR_RCVD_REPRESENTING_NAME));

        // If this meeting request is received by a delegate then open delegator's store.
        if (isset($messageprops[PR_RCVD_REPRESENTING_NAME])) {
            $delegatorStore = $this->getDelegatorStore($messageprops);

            $store = $delegatorStore['store'];
            $calFolder = $delegatorStore['calFolder'];
        } else {
            $calFolder = $this->openDefaultCalendar();
            $store = $this->store;
        }

        $goid = $messageprops[$this->proptags['goid']];

        // First, find the items in the calendar by GlobalObjid (0x3)
        $entryids = $this->findCalendarItems($goid, $calFolder);

        if (!$basedate)
            $basedate = $this->getBasedateFromGlobalID($goid);

        if($sendresponse)
            $this->createResponse(olResponseDeclined, false, false, $body, $store, $basedate, $calFolder);

        if ($basedate) {
            // use CleanGlobalObjid (0x23)
            $calendaritems = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder);

            foreach($calendaritems as $entryid) {
                // Open each calendar item and set the properties of the cancellation object
                $calendaritem = mapi_msgstore_openentry($store, $entryid);

                // Recurring item is found, now delete exception
                if ($calendaritem)
                    $this->doRemoveExceptionFromCalendar($basedate, $calendaritem, $store);
            }

            if ($this->isMeetingRequest())
                $calendaritem = false;
            else
                $result = false;
        }

        if (!$calendaritem) {
            $calendar = $this->openDefaultCalendar();

            if(!empty($entryids)) {
                mapi_folder_deletemessages($calendar, $entryids);
            }

            // All we have to do to decline, is to move the item to the waste basket
            $wastebasket = $this->openDefaultWastebasket();
            $sourcefolder = $this->openParentFolder();

            $messageprops = mapi_getprops($this->message, Array(PR_ENTRYID));

            // Release the message
            $this->message = null;

            // Move the message to the waste basket
            mapi_folder_copymessages($sourcefolder, Array($messageprops[PR_ENTRYID]), $wastebasket, MESSAGE_MOVE);
        }
        return $result;
    }

    /**
     * Removes a meeting request from the calendar when the user presses the
     * 'remove from calendar' button in response to a meeting cancellation.
     * @param string $basedate if specified contains starttime of day of an occurrence
     */
    function doRemoveFromCalendar($basedate)
    {
        if($this->isLocalOrganiser())
            return false;

        $store = $this->store;
        $messageprops = mapi_getprops($this->message, Array(PR_ENTRYID, $this->proptags['goid'], PR_RCVD_REPRESENTING_NAME, PR_MESSAGE_CLASS));
        $goid = $messageprops[$this->proptags['goid']];

        if (isset($messageprops[PR_RCVD_REPRESENTING_NAME])) {
            $delegatorStore = $this->getDelegatorStore($messageprops);
            $store = $delegatorStore['store'];
            $calFolder = $delegatorStore['calFolder'];
        } else {
            $calFolder = $this->openDefaultCalendar();
        }

        $wastebasket = $this->openDefaultWastebasket();
        $sourcefolder = $this->openParentFolder();

        // Check if the message is a meeting request in the inbox or a calendaritem by checking the message class
        if (strpos($messageprops[PR_MESSAGE_CLASS], 'IPM.Schedule.Meeting') === 0) {
            /**
             * 'Remove from calendar' option from previewpane then we have to check GlobalID of this meeting request.
             * If basedate found then open meeting from calendar and delete that occurence.
             */
            $basedate = false;
            if ($goid) {
                // Retrieve GlobalID and find basedate in it.
                $basedate = $this->getBasedateFromGlobalID($goid);

                // Basedate found, Now find item.
                if ($basedate) {
                    $guid = $this->setBasedateInGlobalID($goid);

                    // First, find the items in the calendar by GOID
                    $calendaritems = $this->findCalendarItems($guid, $calFolder);
                    if(is_array($calendaritems)) {
                        foreach($calendaritems as $entryid) {
                            // Open each calendar item and set the properties of the cancellation object
                            $calendaritem = mapi_msgstore_openentry($store, $entryid);

                            if ($calendaritem){
                                $this->doRemoveExceptionFromCalendar($basedate, $calendaritem, $store);
                            }
                        }
                    }
                }
            }

            // It is normal/recurring meeting item.
            if (!$basedate) {
                if (!isset($calFolder)) $calFolder = $this->openDefaultCalendar();

                $entryids = $this->findCalendarItems($goid, $calFolder);

                if(is_array($entryids)){
                    // Move the calendaritem to the waste basket
                    mapi_folder_copymessages($sourcefolder, $entryids, $wastebasket, MESSAGE_MOVE);
                }
            }

            // Release the message
            $this->message = null;

            // Move the message to the waste basket
            mapi_folder_copymessages($sourcefolder, Array($messageprops[PR_ENTRYID]), $wastebasket, MESSAGE_MOVE);

        } else {
            // Here only properties are set on calendaritem, because user is responding from calendar.
            if ($basedate) { //remove the occurence
                $this->doRemoveExceptionFromCalendar($basedate, $this->message, $store);
            } else { //remove normal/recurring meeting item.
                // Move the message to the waste basket
                mapi_folder_copymessages($sourcefolder, Array($messageprops[PR_ENTRYID]), $wastebasket, MESSAGE_MOVE);
            }
        }
    }

    /**
     * Removes the meeting request by moving the item to the deleted
     * items folder. After canceling, youcan't use this class instance
     * any more. The message is closed.
     */
    function doCancel()
    {
        if($this->isLocalOrganiser())
            return;
        if(!$this->isMeetingCancellation())
            return;

        // Remove any previous calendar items with this goid and appt id
        $messageprops = mapi_getprops($this->message, Array($this->proptags['goid']));
        $goid = $messageprops[$this->proptags['goid']];

        $entryids = $this->findCalendarItems($goid);
        $calendar = $this->openDefaultCalendar();

        mapi_folder_deletemessages($calendar, $entryids);

        // All we have to do to decline, is to move the item to the waste basket

        $wastebasket = $this->openDefaultWastebasket();
        $sourcefolder = $this->openParentFolder();

        $messageprops = mapi_getprops($this->message, Array(PR_ENTRYID));

        // Release the message
        $this->message = null;

        // Move the message to the waste basket
        mapi_folder_copymessages($sourcefolder, Array($messageprops[PR_ENTRYID]), $wastebasket, MESSAGE_MOVE);
    }


    /**
     * Sets the properties in the message so that is can be sent
     * as a meeting request. The caller has to submit the message. This
     * is only used for new MeetingRequests. Pass the appointment item as $message
     * in the constructor to do this.
     */
    function setMeetingRequest($basedate = false)
    {
        $props = mapi_getprops($this->message, Array($this->proptags['updatecounter']));

        // Create a new global id for this item
        $goid = pack("H*", "040000008200E00074C5B7101A82E00800000000");
        for ($i=0; $i<36; $i++)
            $goid .= chr(rand(0, 255));

        // Create a new appointment id for this item
        $apptid = rand();

        $props[PR_OWNER_APPT_ID] = $apptid;
        $props[PR_ICON_INDEX] = 1026;
        $props[$this->proptags['goid']] = $goid;
        $props[$this->proptags['goid2']] = $goid;

        if (!isset($props[$this->proptags['updatecounter']])) {
            $props[$this->proptags['updatecounter']] = 0;            // OL also starts sequence no with zero.
            $props[$this->proptags['last_updatecounter']] = 0;
        }

        mapi_setprops($this->message, $props);
    }

    /**
     * Sends a meeting request by copying it to the outbox, converting
     * the message class, adding some properties that are required only
     * for sending the message and submitting the message. Set cancel to
     * true if you wish to completely cancel the meeting request. You can
     * specify an optional 'prefix' to prefix the sent message, which is normally
     * 'Canceled: '
     */
    function sendMeetingRequest($cancel, $prefix = false, $basedate = false, $deletedRecips = false)
    {
        $this->includesResources = false;
        $this->nonAcceptingResources = Array();

        // Get the properties of the message
        $messageprops = mapi_getprops($this->message, Array($this->proptags['recurring']));

        /*****************************************************************************************
         * Submit message to non-resource recipients
         */
        // Set BusyStatus to olTentative (1)
        // Set MeetingStatus to olMeetingReceived
        // Set ResponseStatus to olResponseNotResponded

        /**
         * While sending recurrence meeting exceptions are not send as attachments
         * because first all exceptions are send and then recurrence meeting is sent.
         */
        if (isset($messageprops[$this->proptags['recurring']]) && $messageprops[$this->proptags['recurring']] && !$basedate) {
            // Book resource
            $resourceRecipData = $this->bookResources($this->message, $cancel, $prefix);

            if (!$this->errorSetResource) {
                $recurr = new Recurrence($this->openDefaultStore(), $this->message);

                // First send meetingrequest for recurring item
                $this->submitMeetingRequest($this->message, $cancel, $prefix, false, $recurr, false, $deletedRecips);

                // Then send all meeting request for all exceptions
                $exceptions = $recurr->getAllExceptions();
                if ($exceptions) {
                    foreach($exceptions as $exceptionBasedate) {
                        $attach = $recurr->getExceptionAttachment($exceptionBasedate);

                        if ($attach) {
                            $occurrenceItem = mapi_attach_openobj($attach, MAPI_MODIFY);
                            $this->submitMeetingRequest($occurrenceItem, $cancel, false, $exceptionBasedate, $recurr, false, $deletedRecips);
                            mapi_savechanges($attach);
                        }
                    }
                }
            }
        } else {
            // Basedate found, an exception is to be send
            if ($basedate) {
                $recurr = new Recurrence($this->openDefaultStore(), $this->message);

                if ($cancel) {
                    //@TODO: remove occurrence from Resource's Calendar if resource was booked for whole series
                    $this->submitMeetingRequest($this->message, $cancel, $prefix, $basedate, $recurr, false);
                } else {
                    $attach = $recurr->getExceptionAttachment($basedate);

                    if ($attach) {
                        $occurrenceItem = mapi_attach_openobj($attach, MAPI_MODIFY);

                        // Book resource for this occurrence
                        $resourceRecipData = $this->bookResources($occurrenceItem, $cancel, $prefix, $basedate);

                        if (!$this->errorSetResource) {
                            // Save all previous changes
                            mapi_savechanges($this->message);

                            $this->submitMeetingRequest($occurrenceItem, $cancel, $prefix, $basedate, $recurr, true, $deletedRecips);
                            mapi_savechanges($occurrenceItem);
                            mapi_savechanges($attach);
                        }
                    }
                }
            } else {
                // This is normal meeting
                $resourceRecipData = $this->bookResources($this->message, $cancel, $prefix);

                if (!$this->errorSetResource) {
                    $this->submitMeetingRequest($this->message, $cancel, $prefix, false, false, false, $deletedRecips);
                }
            }
        }

        if(isset($this->errorSetResource) && $this->errorSetResource){
            return Array(
                'error' => $this->errorSetResource,
                'displayname' => $this->recipientDisplayname
            );
        }else{
            return true;
        }
    }


    function getFreeBusyInfo($entryID,$start,$end)
    {
        $result = array();
        $fbsupport = mapi_freebusysupport_open($this->session);

        if(mapi_last_hresult() != NOERROR) {
            if(function_exists("dump")) {
                dump("Error in opening freebusysupport object.");
            }
            return $result;
        }

        $fbDataArray = mapi_freebusysupport_loaddata($fbsupport, array($entryID));

        if($fbDataArray[0] != NULL){
            foreach($fbDataArray as $fbDataUser){
                $rangeuser1 = mapi_freebusydata_getpublishrange($fbDataUser);
                if($rangeuser1 == NULL){
                    return $result;
                }

                $enumblock = mapi_freebusydata_enumblocks($fbDataUser, $start, $end);
                mapi_freebusyenumblock_reset($enumblock);

                while(true){
                    $blocks = mapi_freebusyenumblock_next($enumblock, 100);
                    if(!$blocks){
                        break;
                    }
                    foreach($blocks as $blockItem){
                        $result[] = $blockItem;
                    }
                }
            }
        }

        mapi_freebusysupport_close($fbsupport);
        return $result;
    }

    /**
     * Updates the message after an update has been performed (for example,
     * changing the time of the meeting). This must be called before re-sending
     * the meeting request. You can also call this function instead of 'setMeetingRequest()'
     * as it will automatically call setMeetingRequest on this object if it is the first
     * call to this function.
     */
    function updateMeetingRequest($basedate = false)
    {
        $messageprops = mapi_getprops($this->message, Array($this->proptags['last_updatecounter'], $this->proptags['goid']));

        if(!isset($messageprops[$this->proptags['last_updatecounter']]) || !isset($messageprops[$this->proptags['goid']])) {
            $this->setMeetingRequest($basedate);
        } else {
            $counter = $messageprops[$this->proptags['last_updatecounter']] + 1;

            // increment value of last_updatecounter, last_updatecounter will be common for recurring series
            // so even if you sending an exception only you need to update the last_updatecounter in the recurring series message
            // this way we can make sure that everytime we will be using a uniwue number for every operation
            mapi_setprops($this->message, Array($this->proptags['last_updatecounter'] => $counter));
        }
    }

    /**
     * Returns TRUE if we are the organiser of the meeting.
     */
    function isLocalOrganiser()
    {
        if($this->isMeetingRequest() || $this->isMeetingRequestResponse()) {
            $messageid = $this->getAppointmentEntryID();

            if(!isset($messageid))
                return false;

            $message = mapi_msgstore_openentry($this->store, $messageid);

            $messageprops = mapi_getprops($this->message, Array($this->proptags['goid']));
            $basedate = $this->getBasedateFromGlobalID($messageprops[$this->proptags['goid']]);
            if ($basedate) {
                $recurr = new Recurrence($this->store, $message);
                $attach = $recurr->getExceptionAttachment($basedate);
                if ($attach) {
                    $occurItem = mapi_attach_openobj($attach);
                    $occurItemProps = mapi_getprops($occurItem, Array($this->proptags['responsestatus']));
                }
            }

            $messageprops = mapi_getprops($message, Array($this->proptags['responsestatus']));
        }

        /**
         * User can send recurring meeting or any occurrences from a recurring appointment so
         * to be organizer 'responseStatus' property should be 'olResponseOrganized' on either
         * of the recurring item or occurrence item.
         */
        if ((isset($messageprops[$this->proptags['responsestatus']]) && $messageprops[$this->proptags['responsestatus']] == olResponseOrganized)
            || (isset($occurItemProps[$this->proptags['responsestatus']]) && $occurItemProps[$this->proptags['responsestatus']] == olResponseOrganized))
            return true;
        else
            return false;
    }

    /**
     * Returns the entryid of the appointment that this message points at. This is
     * only used on messages that are not in the calendar.
     */
    function getAppointmentEntryID()
    {
        $messageprops = mapi_getprops($this->message, Array($this->proptags['goid2']));

        $goid2 = $messageprops[$this->proptags['goid2']];

        $items = $this->findCalendarItems($goid2);

        if(empty($items))
            return;

        // There should be just one item. If there are more, we just take the first one
        return $items[0];
    }

    /***************************************************************************************************
     * Support functions - INTERNAL ONLY
     ***************************************************************************************************
     */

    /**
     * Return the tracking status of a recipient based on the IPM class (passed)
     */
    function getTrackStatus($class) {
        $status = olRecipientTrackStatusNone;
        switch($class)
        {
            case "IPM.Schedule.Meeting.Resp.Pos":
                $status = olRecipientTrackStatusAccepted;
                break;

            case "IPM.Schedule.Meeting.Resp.Tent":
                $status = olRecipientTrackStatusTentative;
                break;

            case "IPM.Schedule.Meeting.Resp.Neg":
                $status = olRecipientTrackStatusDeclined;
                break;
        }
        return $status;
    }

    function openParentFolder() {
        $messageprops = mapi_getprops($this->message, Array(PR_PARENT_ENTRYID));

        $parentfolder = mapi_msgstore_openentry($this->store, $messageprops[PR_PARENT_ENTRYID]);
        return $parentfolder;
    }

    function openDefaultCalendar() {
        return $this->openDefaultFolder(PR_IPM_APPOINTMENT_ENTRYID);
    }

    function openDefaultOutbox($store=false) {
        return $this->openBaseFolder(PR_IPM_OUTBOX_ENTRYID, $store);
    }

    function openDefaultWastebasket() {
        return $this->openBaseFolder(PR_IPM_WASTEBASKET_ENTRYID);
    }

    function getDefaultWastebasketEntryID() {
        return $this->getBaseEntryID(PR_IPM_WASTEBASKET_ENTRYID);
    }

    function getDefaultSentmailEntryID($store=false) {
        return $this->getBaseEntryID(PR_IPM_SENTMAIL_ENTRYID, $store);
    }

    function getDefaultFolderEntryID($prop) {
        try {
            $inbox = mapi_msgstore_getreceivefolder($this->store);
        } catch (MAPIException $e) {
            // public store doesn't support this method
            if($e->getCode() == MAPI_E_NO_SUPPORT) {
                // don't propogate this error to parent handlers, if store doesn't support it
                $e->setHandled();
                return;
            }
        }

        $inboxprops = mapi_getprops($inbox, Array($prop));
        if(!isset($inboxprops[$prop]))
            return;

        return $inboxprops[$prop];
    }

    function openDefaultFolder($prop) {
        $entryid = $this->getDefaultFolderEntryID($prop);
        $folder = mapi_msgstore_openentry($this->store, $entryid);

        return $folder;
    }

    function getBaseEntryID($prop, $store=false) {
        $storeprops = mapi_getprops( (($store)?$store:$this->store) , Array($prop));
        if(!isset($storeprops[$prop]))
            return;

        return $storeprops[$prop];
    }

    function openBaseFolder($prop, $store=false) {
        $entryid = $this->getBaseEntryID($prop, $store);
        $folder = mapi_msgstore_openentry( (($store)?$store:$this->store) , $entryid);

        return $folder;
    }
    /**
     * Function which sends response to organizer when attendee accepts, declines or proposes new time to a received meeting request.
     *@param integer $status response status of attendee
     *@param integer $proposalStartTime proposed starttime by attendee
     *@param integer $proposalEndTime proposed endtime by attendee
     *@param integer $basedate date of occurrence which attendee has responded
     */
    function createResponse($status, $proposalStartTime=false, $proposalEndTime=false, $body=false, $store, $basedate = false, $calFolder) {
        $messageprops = mapi_getprops($this->message, Array(PR_SENT_REPRESENTING_ENTRYID,
                                                            PR_SENT_REPRESENTING_EMAIL_ADDRESS,
                                                            PR_SENT_REPRESENTING_ADDRTYPE,
                                                            PR_SENT_REPRESENTING_NAME,
                                                            $this->proptags['goid'],
                                                            $this->proptags['goid2'],
                                                            $this->proptags['location'],
                                                            $this->proptags['startdate'],
                                                            $this->proptags['duedate'],
                                                            $this->proptags['recurring'],
                                                            $this->proptags['recurring_pattern'],
                                                            $this->proptags['recurrence_data'],
                                                            $this->proptags['timezone_data'],
                                                            $this->proptags['timezone'],
                                                            $this->proptags['updatecounter'],
                                                            PR_SUBJECT,
                                                            PR_MESSAGE_CLASS,
                                                            PR_OWNER_APPT_ID,
                                                            $this->proptags['is_exception']
                                    ));

        if ($basedate && $messageprops[PR_MESSAGE_CLASS] != "IPM.Schedule.Meeting.Request" ){
            // we are creating response from a recurring calendar item object
            // We found basedate,so opened occurrence and get properties.
            $recurr = new Recurrence($store, $this->message);
            $exception = $recurr->getExceptionAttachment($basedate);

            if ($exception) {
                // Exception found, Now retrieve properties
                $imessage = mapi_attach_openobj($exception, 0);
                $imsgprops = mapi_getprops($imessage);

                // If location is provided, copy it to the response
                if (isset($imsgprops[$this->proptags['location']])) {
                    $messageprops[$this->proptags['location']] = $imsgprops[$this->proptags['location']];
                }

                // Update $messageprops with timings of occurrence
                $messageprops[$this->proptags['startdate']] = $imsgprops[$this->proptags['startdate']];
                $messageprops[$this->proptags['duedate']] = $imsgprops[$this->proptags['duedate']];

                // Meeting related properties
                $props[$this->proptags['meetingstatus']] = $imsgprops[$this->proptags['meetingstatus']];
                $props[$this->proptags['responsestatus']] = $imsgprops[$this->proptags['responsestatus']];
                $props[PR_SUBJECT] = $imsgprops[PR_SUBJECT];
            } else {
                // Exceptions is deleted.
                // Update $messageprops with timings of occurrence
                $messageprops[$this->proptags['startdate']] = $recurr->getOccurrenceStart($basedate);
                $messageprops[$this->proptags['duedate']] = $recurr->getOccurrenceEnd($basedate);

                $props[$this->proptags['meetingstatus']] = olNonMeeting;
                $props[$this->proptags['responsestatus']] = olResponseNone;
            }

            $props[$this->proptags['recurring']] = false;
            $props[$this->proptags['is_exception']] = true;
        } else {
            // we are creating a response from meeting request mail (it could be recurring or non-recurring)
            // Send all recurrence info in response, if this is a recurrence meeting.
            $isRecurring = isset($messageprops[$this->proptags['recurring']]) && $messageprops[$this->proptags['recurring']];
            $isException = isset($messageprops[$this->proptags['is_exception']]) && $messageprops[$this->proptags['is_exception']];
            if ($isRecurring || $isException) {
                if($isRecurring) {
                    $props[$this->proptags['recurring']] = $messageprops[$this->proptags['recurring']];
                }
                if($isException) {
                    $props[$this->proptags['is_exception']] = $messageprops[$this->proptags['is_exception']];
                }
                $calendaritems = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder);

                $calendaritem = mapi_msgstore_openentry($this->store, $calendaritems[0]);
                $recurr = new Recurrence($store, $calendaritem);
            }
        }

        // we are sending a response for recurring meeting request (or exception), so set some required properties
        if(isset($recurr) && $recurr) {
            if(!empty($messageprops[$this->proptags['recurring_pattern']])) {
                $props[$this->proptags['recurring_pattern']] = $messageprops[$this->proptags['recurring_pattern']];
            }

            if(!empty($messageprops[$this->proptags['recurrence_data']])) {
                $props[$this->proptags['recurrence_data']] = $messageprops[$this->proptags['recurrence_data']];
            }

            $props[$this->proptags['timezone_data']] = $messageprops[$this->proptags['timezone_data']];
            $props[$this->proptags['timezone']] = $messageprops[$this->proptags['timezone']];

            $this->generateRecurDates($recurr, $messageprops, $props);
        }

        // Create a response message
        $recip = Array();
        $recip[PR_ENTRYID] = $messageprops[PR_SENT_REPRESENTING_ENTRYID];
        $recip[PR_EMAIL_ADDRESS] = $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
        $recip[PR_ADDRTYPE] = $messageprops[PR_SENT_REPRESENTING_ADDRTYPE];
        $recip[PR_DISPLAY_NAME] = $messageprops[PR_SENT_REPRESENTING_NAME];
        $recip[PR_RECIPIENT_TYPE] = MAPI_TO;

        switch($status) {
            case olResponseAccepted:
                $classpostfix = "Pos";
                $subjectprefix = _("Accepted");
                break;
            case olResponseDeclined:
                $classpostfix = "Neg";
                $subjectprefix = _("Declined");
                break;
            case olResponseTentative:
                $classpostfix = "Tent";
                $subjectprefix = _("Tentatively accepted");
                break;
        }

        if($proposalStartTime && $proposalEndTime){
            // if attendee has proposed new time then change subject prefix
            $subjectprefix = _("New Time Proposed");
        }

        $props[PR_SUBJECT] = $subjectprefix . ": " . $messageprops[PR_SUBJECT];

        $props[PR_MESSAGE_CLASS] = "IPM.Schedule.Meeting.Resp." . $classpostfix;
        if(isset($messageprops[PR_OWNER_APPT_ID]))
            $props[PR_OWNER_APPT_ID] = $messageprops[PR_OWNER_APPT_ID];

        // Set GLOBALID AND CLEANGLOBALID, if exception then also set basedate into GLOBALID(0x3).
        $props[$this->proptags['goid']] = $this->setBasedateInGlobalID($messageprops[$this->proptags['goid2']], $basedate);
        $props[$this->proptags['goid2']] = $messageprops[$this->proptags['goid2']];
        $props[$this->proptags['updatecounter']] = $messageprops[$this->proptags['updatecounter']];

        // get the default store, in which we have to store the accepted email by delegate or normal user.
        $defaultStore = $this->openDefaultStore();
        $props[PR_SENTMAIL_ENTRYID] = $this->getDefaultSentmailEntryID($defaultStore);

        if($proposalStartTime && $proposalEndTime){
            $props[$this->proptags['proposed_start_whole']] = $proposalStartTime;
            $props[$this->proptags['proposed_end_whole']] = $proposalEndTime;
            $props[$this->proptags['proposed_duration']] = round($proposalEndTime - $proposalStartTime)/60;
            $props[$this->proptags['counter_proposal']] = true;
        }

        //Set body message in Appointment
        if(isset($body)) {
            $props[PR_BODY] = $this->getMeetingTimeInfo() ? $this->getMeetingTimeInfo() : $body;
        }

        // PR_START_DATE/PR_END_DATE is used in the UI in Outlook on the response message
        $props[PR_START_DATE] = $messageprops[$this->proptags['startdate']];
        $props[PR_END_DATE] = $messageprops[$this->proptags['duedate']];

        // Set startdate and duedate in response mail.
        $props[$this->proptags['startdate']] = $messageprops[$this->proptags['startdate']];
        $props[$this->proptags['duedate']] = $messageprops[$this->proptags['duedate']];

        // responselocation is used in the UI in Outlook on the response message
        if (isset($messageprops[$this->proptags['location']])) {
            $props[$this->proptags['responselocation']] = $messageprops[$this->proptags['location']];
            $props[$this->proptags['location']] = $messageprops[$this->proptags['location']];
        }

        // check if $store is set and it is not equal to $defaultStore (means its the delegation case)
        if(isset($store) && isset($defaultStore)) {
            $storeProps = mapi_getprops($store, array(PR_ENTRYID));
            $defaultStoreProps = mapi_getprops($defaultStore, array(PR_ENTRYID));

            if($storeProps[PR_ENTRYID] !== $defaultStoreProps[PR_ENTRYID]){
                // get the properties of the other user (for which the logged in user is a delegate).
                $storeProps = mapi_getprops($store, array(PR_MAILBOX_OWNER_ENTRYID));
                $addrbook = mapi_openaddressbook($this->session);
                $addrbookitem = mapi_ab_openentry($addrbook, $storeProps[PR_MAILBOX_OWNER_ENTRYID]);
                $addrbookitemprops = mapi_getprops($addrbookitem, array(PR_DISPLAY_NAME, PR_EMAIL_ADDRESS));

                // setting the following properties will ensure that the delegation part of message.
                $props[PR_SENT_REPRESENTING_ENTRYID] = $storeProps[PR_MAILBOX_OWNER_ENTRYID];
                $props[PR_SENT_REPRESENTING_NAME] = $addrbookitemprops[PR_DISPLAY_NAME];
                $props[PR_SENT_REPRESENTING_EMAIL_ADDRESS] = $addrbookitemprops[PR_EMAIL_ADDRESS];
                $props[PR_SENT_REPRESENTING_ADDRTYPE] = "ZARAFA";

                // get the properties of default store and set it accordingly
                $defaultStoreProps = mapi_getprops($defaultStore, array(PR_MAILBOX_OWNER_ENTRYID));
                $addrbookitem = mapi_ab_openentry($addrbook, $defaultStoreProps[PR_MAILBOX_OWNER_ENTRYID]);
                $addrbookitemprops = mapi_getprops($addrbookitem, array(PR_DISPLAY_NAME, PR_EMAIL_ADDRESS));

                // set the following properties will ensure the sender's details, which will be the default user in this case.
                //the function returns array($name, $emailaddr, $addrtype, $entryid, $searchkey);
                $defaultUserDetails = $this->getOwnerAddress($defaultStore);
                $props[PR_SENDER_ENTRYID] = $defaultUserDetails[3];
                $props[PR_SENDER_EMAIL_ADDRESS] = $defaultUserDetails[1];
                $props[PR_SENDER_NAME] = $defaultUserDetails[0];
                $props[PR_SENDER_ADDRTYPE] = $defaultUserDetails[2];
            }
        }

        // pass the default store to get the required store.
        $outbox = $this->openDefaultOutbox($defaultStore);

        $message = mapi_folder_createmessage($outbox);
        mapi_setprops($message, $props);
        mapi_message_modifyrecipients($message, MODRECIP_ADD, Array($recip));
        mapi_message_savechanges($message);
        mapi_message_submitmessage($message);
    }

    /**
     * Function which finds items in calendar based on specified parameters.
     *@param binary $goid GlobalID(0x3) of item
     *@param resource $calendar MAPI_folder of user
     *@param boolean $use_cleanGlobalID if true then search should be performed on cleanGlobalID(0x23) else globalID(0x3)
     */
    function findCalendarItems($goid, $calendar = false, $use_cleanGlobalID = false) {
        if(!$calendar) {
            // Open the Calendar
            $calendar = $this->openDefaultCalendar();
        }

        // Find the item by restricting all items to the correct ID
        $restrict = Array(RES_AND, Array());

        array_push($restrict[1], Array(RES_PROPERTY,
                                                    Array(RELOP => RELOP_EQ,
                                                          ULPROPTAG => ($use_cleanGlobalID ? $this->proptags['goid2'] : $this->proptags['goid']),
                                                          VALUE => $goid
                                                    )
                                    ));

        $calendarcontents = mapi_folder_getcontentstable($calendar);

        $rows = mapi_table_queryallrows($calendarcontents, Array(PR_ENTRYID), $restrict);

        if(empty($rows))
            return;

        $calendaritems = Array();

        // In principle, there should only be one row, but we'll handle them all just in case
        foreach($rows as $row) {
            $calendaritems[] = $row[PR_ENTRYID];
        }

        return $calendaritems;
    }

    // Returns TRUE if both entryid's are equal. Equality is defined by both entryid's pointing at the
    // same SMTP address when converted to SMTP
    function compareABEntryIDs($entryid1, $entryid2) {
        // If the session was not passed, just do a 'normal' compare.
        if(!$this->session)
            return $entryid1 == $entryid2;

        $smtp1 = $this->getSMTPAddress($entryid1);
        $smtp2 = $this->getSMTPAddress($entryid2);

        if($smtp1 == $smtp2)
            return true;
        else
            return false;
    }

    // Gets the SMTP address of the passed addressbook entryid
    function getSMTPAddress($entryid) {
        if(!$this->session)
            return false;

        $ab = mapi_openaddressbook($this->session);

        $abitem = mapi_ab_openentry($ab, $entryid);

        if(!$abitem)
            return "";

        $props = mapi_getprops($abitem, array(PR_ADDRTYPE, PR_EMAIL_ADDRESS, PR_SMTP_ADDRESS));

        if($props[PR_ADDRTYPE] == "SMTP") {
            return $props[PR_EMAIL_ADDRESS];
        }
        else return $props[PR_SMTP_ADDRESS];
    }

    /**
     * Gets the properties associated with the owner of the passed store:
     * PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_ADDRTYPE, PR_ENTRYID, PR_SEARCH_KEY
     *
     * @param $store message store
     * @param $fallbackToLoggedInUser if true then return properties of logged in user instead of mailbox owner
     * not used when passed store is public store. for public store we are always returning logged in user's info.
     * @return properties of logged in user in an array in sequence of display_name, email address, address tyep,
     * entryid and search key.
     */
    function getOwnerAddress($store, $fallbackToLoggedInUser = true)
    {
        if(!$this->session)
            return false;

        $storeProps = mapi_getprops($store, array(PR_MAILBOX_OWNER_ENTRYID, PR_USER_ENTRYID));

        $ownerEntryId = false;
        if(isset($storeProps[PR_USER_ENTRYID]) && $storeProps[PR_USER_ENTRYID]) {
            $ownerEntryId = $storeProps[PR_USER_ENTRYID];
        }

        if(isset($storeProps[PR_MAILBOX_OWNER_ENTRYID]) && $storeProps[PR_MAILBOX_OWNER_ENTRYID] && !$fallbackToLoggedInUser) {
            $ownerEntryId = $storeProps[PR_MAILBOX_OWNER_ENTRYID];
        }

        if($ownerEntryId) {
            $ab = mapi_openaddressbook($this->session);

            $zarafaUser = mapi_ab_openentry($ab, $ownerEntryId);
            if(!$zarafaUser)
                return false;

            $ownerProps = mapi_getprops($zarafaUser, array(PR_ADDRTYPE, PR_DISPLAY_NAME, PR_EMAIL_ADDRESS));

            $addrType = $ownerProps[PR_ADDRTYPE];
            $name = $ownerProps[PR_DISPLAY_NAME];
            $emailAddr = $ownerProps[PR_EMAIL_ADDRESS];
            $searchKey = strtoupper($addrType) . ":" . strtoupper($emailAddr);
            $entryId = $ownerEntryId;

            return array($name, $emailAddr, $addrType, $entryId, $searchKey);
        }

        return false;
    }

    // Opens this session's default message store
    function openDefaultStore()
    {
        $storestable = mapi_getmsgstorestable($this->session);
        $rows = mapi_table_queryallrows($storestable, array(PR_ENTRYID, PR_DEFAULT_STORE));
        $entry = false;

        foreach($rows as $row) {
            if(isset($row[PR_DEFAULT_STORE]) && $row[PR_DEFAULT_STORE]) {
                $entryid = $row[PR_ENTRYID];
                break;
            }
        }

        if(!$entryid)
            return false;

        return mapi_openmsgstore($this->session, $entryid);
    }
    /**
     *  Function which adds organizer to recipient list which is passed.
     *  This function also checks if it has organizer.
     *
     * @param array $messageProps message properties
     * @param array $recipients    recipients list of message.
     * @param boolean $isException true if we are processing recipient of exception
     */
    function addOrganizer($messageProps, &$recipients, $isException = false){

        $hasOrganizer = false;
        // Check if meeting already has an organizer.
        foreach ($recipients as $key => $recipient){
            if (isset($recipient[PR_RECIPIENT_FLAGS]) && $recipient[PR_RECIPIENT_FLAGS] == (recipSendable | recipOrganizer)) {
                $hasOrganizer = true;
            } else if ($isException && !isset($recipient[PR_RECIPIENT_FLAGS])){
                // Recipients for an occurrence
                $recipients[$key][PR_RECIPIENT_FLAGS] = recipSendable | recipExceptionalResponse;
            }
        }

        if (!$hasOrganizer){
            // Create organizer.
            $organizer = array();
            $organizer[PR_ENTRYID] = $messageProps[PR_SENT_REPRESENTING_ENTRYID];
            $organizer[PR_DISPLAY_NAME] = $messageProps[PR_SENT_REPRESENTING_NAME];
            $organizer[PR_EMAIL_ADDRESS] = $messageProps[PR_SENT_REPRESENTING_EMAIL_ADDRESS];
            $organizer[PR_RECIPIENT_TYPE] = MAPI_TO;
            $organizer[PR_RECIPIENT_DISPLAY_NAME] = $messageProps[PR_SENT_REPRESENTING_NAME];
            $organizer[PR_ADDRTYPE] = empty($messageProps[PR_SENT_REPRESENTING_ADDRTYPE]) ? 'SMTP':$messageProps[PR_SENT_REPRESENTING_ADDRTYPE];
            $organizer[PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusNone;
            $organizer[PR_RECIPIENT_FLAGS] = recipSendable | recipOrganizer;

            // Add organizer to recipients list.
            array_unshift($recipients, $organizer);
        }
    }

    /**
     * Function adds recipients in recips array from the string.
     *
     * @param array $recips recipient array.
     * @param string $recipString recipient string attendees.
     * @param int $type type of the recipient, MAPI_TO/MAPI_CC.
     */
    function setRecipsFromString(&$recips, $recipString, $recipType = MAPI_TO)
    {
        $extraRecipient = array();
        $recipArray = explode(";", $recipString);

        foreach($recipArray as $recip) {
            $recip = trim($recip);
            if (!empty($recip)) {
                $extraRecipient[PR_RECIPIENT_TYPE] = $recipType;
                $extraRecipient[PR_DISPLAY_NAME] = $recip;
                array_push($recips, $extraRecipient);
            }
        }

    }

    /**
     * Function which removes an exception/occurrence from recurrencing meeting
     * when a meeting cancellation of an occurrence is processed.
     *@param string $basedate basedate of an occurrence
     *@param resource $message recurring item from which occurrence has to be deleted
     *@param resource $store MAPI_MSG_Store which contains the item
     */
    function doRemoveExceptionFromCalendar($basedate, $message, $store)
    {
        $recurr = new Recurrence($store, $message);
        $recurr->createException(array(), $basedate, true);
        mapi_savechanges($message);
    }

    /**
     * Function which returns basedate of an changed occurrance from globalID of meeting request.
     *@param binary $goid globalID
     *@return boolean true if basedate is found else false it not found
     */
    function getBasedateFromGlobalID($goid)
    {
        $hexguid = bin2hex($goid);
        $hexbase = substr($hexguid, 32, 8);
        $day = hexdec(substr($hexbase, 6, 2));
        $month = hexdec(substr($hexbase, 4, 2));
        $year = hexdec(substr($hexbase, 0, 4));

        if ($day && $month && $year)
            return gmmktime(0, 0, 0, $month, $day, $year);
        else
            return false;
    }

    /**
     * Function which sets basedate in globalID of changed occurrance which is to be send.
     *@param binary $goid globalID
     *@param string basedate of changed occurrance
     *@return binary globalID with basedate in it
     */
    function setBasedateInGlobalID($goid, $basedate = false)
    {
        $hexguid = bin2hex($goid);
        $year = $basedate ? sprintf('%04s', dechex(date('Y', $basedate))) : '0000';
        $month = $basedate ? sprintf('%02s', dechex(date('m', $basedate))) : '00';
        $day = $basedate ? sprintf('%02s', dechex(date('d', $basedate))) : '00';

        return hex2bin(strtoupper(substr($hexguid, 0, 32) . $year . $month . $day . substr($hexguid, 40)));
    }
    /**
     * Function which replaces attachments with copy_from in copy_to.
     *@param resource $copy_from MAPI_message from which attachments are to be copied.
     *@param resource $copy_to MAPI_message to which attachment are to be copied.
     *@param boolean $copyExceptions if true then all exceptions should also be sent as attachments
     */
    function replaceAttachments($copy_from, $copy_to, $copyExceptions = true)
    {
        /* remove all old attachments */
        $attachmentTable = mapi_message_getattachmenttable($copy_to);
        if($attachmentTable) {
            $attachments = mapi_table_queryallrows($attachmentTable, array(PR_ATTACH_NUM, PR_ATTACH_METHOD, PR_EXCEPTION_STARTTIME));

            foreach($attachments as $attach_props){
                /* remove exceptions too? */
                if (!$copyExceptions && $attach_props[PR_ATTACH_METHOD] == 5 && isset($attach_props[PR_EXCEPTION_STARTTIME]))
                    continue;
                mapi_message_deleteattach($copy_to, $attach_props[PR_ATTACH_NUM]);
            }
        }
        $attachmentTable = false;

        /* copy new attachments */
        $attachmentTable = mapi_message_getattachmenttable($copy_from);
        if($attachmentTable) {
            $attachments = mapi_table_queryallrows($attachmentTable, array(PR_ATTACH_NUM, PR_ATTACH_METHOD, PR_EXCEPTION_STARTTIME));

            foreach($attachments as $attach_props){
                if (!$copyExceptions && $attach_props[PR_ATTACH_METHOD] == 5 && isset($attach_props[PR_EXCEPTION_STARTTIME]))
                    continue;

                $attach_old = mapi_message_openattach($copy_from, (int) $attach_props[PR_ATTACH_NUM]);
                $attach_newResourceMsg = mapi_message_createattach($copy_to);
                mapi_copyto($attach_old, array(), array(), $attach_newResourceMsg, 0);
                mapi_savechanges($attach_newResourceMsg);
            }
        }
    }
    /**
     * Function which replaces recipients in copy_to with recipients from copy_from.
     *@param resource $copy_from MAPI_message from which recipients are to be copied.
     *@param resource $copy_to MAPI_message to which recipients are to be copied.
     */
    function replaceRecipients($copy_from, $copy_to, $isDelegate = false)
    {
        $recipienttable = mapi_message_getrecipienttable($copy_from);

        // If delegate, then do not add the delegate in recipients
        if ($isDelegate) {
            $delegate = mapi_getprops($copy_from, array(PR_RECEIVED_BY_EMAIL_ADDRESS));
            $res = array(RES_PROPERTY, array(RELOP => RELOP_NE, ULPROPTAG => PR_EMAIL_ADDRESS, VALUE => $delegate[PR_RECEIVED_BY_EMAIL_ADDRESS]));
            $recipients = mapi_table_queryallrows($recipienttable, $this->recipprops, $res);
        } else {
            $recipients = mapi_table_queryallrows($recipienttable, $this->recipprops);
        }

        $copy_to_recipientTable = mapi_message_getrecipienttable($copy_to);
        $copy_to_recipientRows = mapi_table_queryallrows($copy_to_recipientTable, array(PR_ROWID));
        foreach($copy_to_recipientRows as $recipient) {
            mapi_message_modifyrecipients($copy_to, MODRECIP_REMOVE, array($recipient));
        }

        mapi_message_modifyrecipients($copy_to, MODRECIP_ADD, $recipients);
    }
    /**
     * Function creates meeting item in resource's calendar.
     *@param resource $message MAPI_message which is to create in resource's calendar
     *@param boolean $cancel cancel meeting
     *@param string $prefix prefix for subject of meeting
     */
    function bookResources($message, $cancel, $prefix, $basedate = false)
    {
        if(!$this->enableDirectBooking)
            return array();

        // Get the properties of the message
        $messageprops = mapi_getprops($message);

        if ($basedate) {
            $recurrItemProps = mapi_getprops($this->message, array($this->proptags['goid'], $this->proptags['goid2'], $this->proptags['timezone_data'], $this->proptags['timezone'], PR_OWNER_APPT_ID));

            $messageprops[$this->proptags['goid']] = $this->setBasedateInGlobalID($recurrItemProps[$this->proptags['goid']], $basedate);
            $messageprops[$this->proptags['goid2']] = $recurrItemProps[$this->proptags['goid2']];

            // Delete properties which are not needed.
            $deleteProps = array($this->proptags['basedate'], PR_DISPLAY_NAME, PR_ATTACHMENT_FLAGS, PR_ATTACHMENT_HIDDEN, PR_ATTACHMENT_LINKID, PR_ATTACH_FLAGS, PR_ATTACH_METHOD);
            foreach ($deleteProps as $propID) {
                if (isset($messageprops[$propID])) {
                    unset($messageprops[$propID]);
                }
            }

            if (isset($messageprops[$this->proptags['recurring']])) $messageprops[$this->proptags['recurring']] = false;

            // Set Outlook properties
            $messageprops[$this->proptags['clipstart']] = $messageprops[$this->proptags['startdate']];
            $messageprops[$this->proptags['clipend']] = $messageprops[$this->proptags['duedate']];
            $messageprops[$this->proptags['timezone_data']] = $recurrItemProps[$this->proptags['timezone_data']];
            $messageprops[$this->proptags['timezone']] = $recurrItemProps[$this->proptags['timezone']];
            $messageprops[$this->proptags['attendee_critical_change']] = time();
            $messageprops[$this->proptags['owner_critical_change']] = time();
        }

        // Get resource recipients
        $getResourcesRestriction = Array(RES_AND,
            Array(Array(RES_PROPERTY,
                Array(RELOP => RELOP_EQ,    // Equals recipient type 3: Resource
                    ULPROPTAG => PR_RECIPIENT_TYPE,
                    VALUE => array(PR_RECIPIENT_TYPE =>MAPI_BCC)
                )
            ))
        );
        $recipienttable = mapi_message_getrecipienttable($message);
        $resourceRecipients = mapi_table_queryallrows($recipienttable, $this->recipprops, $getResourcesRestriction);

        $this->errorSetResource = false;
        $resourceRecipData = Array();

        // Put appointment into store resource users
        $i = 0;
        $len = count($resourceRecipients);
        while(!$this->errorSetResource && $i < $len){
            $request = array(array(PR_DISPLAY_NAME => $resourceRecipients[$i][PR_DISPLAY_NAME]));
            $ab = mapi_openaddressbook($this->session);
            $ret = mapi_ab_resolvename($ab, $request, EMS_AB_ADDRESS_LOOKUP);
            $result = mapi_last_hresult();
            if ($result == NOERROR){
                $result = $ret[0][PR_ENTRYID];
            }
            $resourceUsername = $ret[0][PR_EMAIL_ADDRESS];
            $resourceABEntryID = $ret[0][PR_ENTRYID];

            // Get StoreEntryID by username
            $user_entryid = mapi_msgstore_createentryid($this->store, $resourceUsername);

            // Open store of the user
            $userStore = mapi_openmsgstore($this->session, $user_entryid);
            // Open root folder
            $userRoot = mapi_msgstore_openentry($userStore, null);
            // Get calendar entryID
            $userRootProps = mapi_getprops($userRoot, array(PR_STORE_ENTRYID, PR_IPM_APPOINTMENT_ENTRYID, PR_FREEBUSY_ENTRYIDS));

            // Open Calendar folder   [check hresult==0]
            $accessToFolder = false;
            try {
                $calFolder = mapi_msgstore_openentry($userStore, $userRootProps[PR_IPM_APPOINTMENT_ENTRYID]);
                if($calFolder){
                    $calFolderProps = mapi_getProps($calFolder, Array(PR_ACCESS));
                    if(($calFolderProps[PR_ACCESS] & MAPI_ACCESS_CREATE_CONTENTS) !== 0){
                        $accessToFolder = true;
                    }
                }
            } catch (MAPIException $e) {
                $e->setHandled();
                $this->errorSetResource = 1; // No access
            }

            if($accessToFolder) {
                /**
                 * Get the LocalFreebusy message that contains the properties that
                 * are set to accept or decline resource meeting requests
                 */
                // Use PR_FREEBUSY_ENTRYIDS[1] to open folder the LocalFreeBusy msg
                $localFreebusyMsg = mapi_msgstore_openentry($userStore, $userRootProps[PR_FREEBUSY_ENTRYIDS][1]);
                if($localFreebusyMsg){
                    $props = mapi_getprops($localFreebusyMsg, array(PR_PROCESS_MEETING_REQUESTS, PR_DECLINE_RECURRING_MEETING_REQUESTS, PR_DECLINE_CONFLICTING_MEETING_REQUESTS));

                    $acceptMeetingRequests = ($props[PR_PROCESS_MEETING_REQUESTS])?1:0;
                    $declineRecurringMeetingRequests = ($props[PR_DECLINE_RECURRING_MEETING_REQUESTS])?1:0;
                    $declineConflictingMeetingRequests = ($props[PR_DECLINE_CONFLICTING_MEETING_REQUESTS])?1:0;
                    if(!$acceptMeetingRequests){
                        /**
                         * When a resource has not been set to automatically accept meeting requests,
                         * the meeting request has to be sent to him rather than being put directly into
                         * his calendar. No error should be returned.
                         */
                        //$errorSetResource = 2;
                        $this->nonAcceptingResources[] = $resourceRecipients[$i];
                    }else{
                        if($declineRecurringMeetingRequests && !$cancel){
                            // Check if appointment is recurring
                            if($messageprops[ $this->proptags['recurring'] ]){
                                $this->errorSetResource = 3;
                            }
                        }
                        if($declineConflictingMeetingRequests && !$cancel){
                            // Check for conflicting items
                            $conflicting = false;

                            // Open the calendar
                            $calFolder = mapi_msgstore_openentry($userStore, $userRootProps[PR_IPM_APPOINTMENT_ENTRYID]);

                            if($calFolder) {
                                if ($this->isMeetingConflicting($message, $userStore, $calFolder, $messageprops))
                                    $conflicting = true;
                            } else {
                                $this->errorSetResource = 1; // No access
                            }

                            if($conflicting){
                                $this->errorSetResource = 4; // Conflict
                            }
                        }
                    }
                }
            }

            if(!$this->errorSetResource && $accessToFolder){
                /**
                 * First search on GlobalID(0x3)
                 * If (recurring and occurrence) If Resource was booked for only this occurrence then Resource should have only this occurrence in Calendar and not whole series.
                 * If (normal meeting) then GlobalID(0x3) and CleanGlobalID(0x23) are same, so doesnt matter if search is based on GlobalID.
                 */
                $rows = $this->findCalendarItems($messageprops[$this->proptags['goid']], $calFolder);

                /**
                 * If no entry is found then
                 * 1) Resource doesnt have meeting in Calendar. Seriously!!
                 * OR
                 * 2) We were looking for occurrence item but Resource has whole series
                 */
                if(empty($rows)){
                    /**
                     * Now search on CleanGlobalID(0x23) WHY???
                     * Because we are looking recurring item
                     *
                     * Possible results of this search
                     * 1) If Resource was booked for more than one occurrences then this search will return all those occurrence because search is perform on CleanGlobalID
                     * 2) If Resource was booked for whole series then it should return series.
                     */
                    $rows = $this->findCalendarItems($messageprops[$this->proptags['goid2']], $calFolder, true);

                    $newResourceMsg = false;
                    if (!empty($rows)) {
                        // Since we are looking for recurring item, open every result and check for 'recurring' property.
                        foreach($rows as $row) {
                            $ResourceMsg = mapi_msgstore_openentry($userStore, $row);
                            $ResourceMsgProps = mapi_getprops($ResourceMsg, array($this->proptags['recurring']));

                            if (isset($ResourceMsgProps[$this->proptags['recurring']]) && $ResourceMsgProps[$this->proptags['recurring']]) {
                                $newResourceMsg = $ResourceMsg;
                                break;
                            }
                        }
                    }

                    // Still no results found. I giveup, create new message.
                    if (!$newResourceMsg)
                        $newResourceMsg = mapi_folder_createmessage($calFolder);
                }else{
                    $newResourceMsg = mapi_msgstore_openentry($userStore, $rows[0]);
                }

                // Prefix the subject if needed
                if($prefix && isset($messageprops[PR_SUBJECT])) {
                    $messageprops[PR_SUBJECT] = $prefix . $messageprops[PR_SUBJECT];
                }

                // Set status to cancelled if needed
                $messageprops[$this->proptags['busystatus']] = fbBusy; // The default status (Busy)
                if($cancel) {
                    $messageprops[$this->proptags['meetingstatus']] = olMeetingCanceled; // The meeting has been canceled
                    $messageprops[$this->proptags['busystatus']] = fbFree; // Free
                } else {
                    $messageprops[$this->proptags['meetingstatus']] = olMeetingReceived; // The recipient is receiving the request
                }
                $messageprops[$this->proptags['responsestatus']] = olResponseAccepted; // The resource autmatically accepts the appointment

                $messageprops[PR_MESSAGE_CLASS] = "IPM.Appointment";

                // Remove the PR_ICON_INDEX as it is not needed in the sent message and it also
                // confuses the Zarafa webaccess
                $messageprops[PR_ICON_INDEX] = null;
                $messageprops[PR_RESPONSE_REQUESTED] = true;

                $addrinfo = $this->getOwnerAddress($this->store);

                if($addrinfo) {
                    list($ownername, $owneremailaddr, $owneraddrtype, $ownerentryid, $ownersearchkey) = $addrinfo;

                    $messageprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS] = $owneremailaddr;
                    $messageprops[PR_SENT_REPRESENTING_NAME] = $ownername;
                    $messageprops[PR_SENT_REPRESENTING_ADDRTYPE] = $owneraddrtype;
                    $messageprops[PR_SENT_REPRESENTING_ENTRYID] = $ownerentryid;
                    $messageprops[PR_SENT_REPRESENTING_SEARCH_KEY] = $ownersearchkey;

                    $messageprops[$this->proptags['apptreplyname']] = $ownername;
                    $messageprops[$this->proptags['replytime']] = time();
                }

                if ($basedate && isset($ResourceMsgProps[$this->proptags['recurring']]) && $ResourceMsgProps[$this->proptags['recurring']]) {
                    $recurr = new Recurrence($userStore, $newResourceMsg);

                    // Copy recipients list
                    $reciptable = mapi_message_getrecipienttable($message);
                    $recips = mapi_table_queryallrows($reciptable, $this->recipprops);
                    // add owner to recipient table
                    $this->addOrganizer($messageprops, $recips, true);

                    // Update occurrence
                    if($recurr->isException($basedate))
                        $recurr->modifyException($messageprops, $basedate, $recips);
                    else
                        $recurr->createException($messageprops, $basedate, false, $recips);
                } else {

                    mapi_setprops($newResourceMsg, $messageprops);

                    // Copy attachments
                    $this->replaceAttachments($message, $newResourceMsg);

                    // Copy all recipients too
                    $this->replaceRecipients($message, $newResourceMsg);

                    // Now add organizer also to recipient table
                    $recips = Array();
                    $this->addOrganizer($messageprops, $recips);
                    mapi_message_modifyrecipients($newResourceMsg, MODRECIP_ADD, $recips);
                }

                mapi_savechanges($newResourceMsg);

                $resourceRecipData[] = Array(
                    'store' => $userStore,
                    'folder' => $calFolder,
                    'msg' => $newResourceMsg,
                );
                $this->includesResources = true;
            }else{
                /**
                 * If no other errors occured and you have no access to the
                 * folder of the resource, throw an error=1.
                 */
                if(!$this->errorSetResource){
                    $this->errorSetResource = 1;
                }

                for($j = 0, $len = count($resourceRecipData); $j < $len; $j++){
                    // Get the EntryID
                    $props = mapi_message_getprops($resourceRecipData[$j]['msg']);

                    mapi_folder_deletemessages($resourceRecipData[$j]['folder'], Array($props[PR_ENTRYID]), DELETE_HARD_DELETE);
                }
                $this->recipientDisplayname = $resourceRecipients[$i][PR_DISPLAY_NAME];
            }
            $i++;
        }

        /**************************************************************
         * Set the BCC-recipients (resources) tackstatus to accepted.
         */
        // Get resource recipients
        $getResourcesRestriction = Array(RES_AND,
            Array(Array(RES_PROPERTY,
                Array(RELOP => RELOP_EQ,    // Equals recipient type 3: Resource
                    ULPROPTAG => PR_RECIPIENT_TYPE,
                    VALUE => array(PR_RECIPIENT_TYPE =>MAPI_BCC)
                )
            ))
        );
        $recipienttable = mapi_message_getrecipienttable($message);
        $resourceRecipients = mapi_table_queryallrows($recipienttable, $this->recipprops, $getResourcesRestriction);
        if(!empty($resourceRecipients)){
            // Set Tracking status of resource recipients to olResponseAccepted (3)
            for($i = 0, $len = count($resourceRecipients); $i < $len; $i++){
                $resourceRecipients[$i][PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusAccepted;
                $resourceRecipients[$i][PR_RECIPIENT_TRACKSTATUS_TIME] = time();
            }
            mapi_message_modifyrecipients($message, MODRECIP_MODIFY, $resourceRecipients);
        }

        // Publish updated free/busy information
        if(!$this->errorSetResource){
            for($i = 0, $len = count($resourceRecipData); $i < $len; $i++){
                $storeProps = mapi_msgstore_getprops($resourceRecipData[$i]['store'], array(PR_MAILBOX_OWNER_ENTRYID));
                if (isset($storeProps[PR_MAILBOX_OWNER_ENTRYID])){
                    $pub = new FreeBusyPublish($this->session, $resourceRecipData[$i]['store'], $resourceRecipData[$i]['folder'], $storeProps[PR_MAILBOX_OWNER_ENTRYID]);
                    $pub->publishFB(time() - (7 * 24 * 60 * 60), 6 * 30 * 24 * 60 * 60); // publish from one week ago, 6 months ahead
                }
            }
        }

        return $resourceRecipData;
    }
    /**
     * Function which save an exception into recurring item
     *
     * @param resource $recurringItem reference to MAPI_message of recurring item
     * @param resource $occurrenceItem reference to MAPI_message of occurrence
     * @param string $basedate basedate of occurrence
     * @param boolean $move if true then occurrence item is deleted
     * @param boolean $tentative true if user has tentatively accepted it or false if user has accepted it.
     * @param boolean $userAction true if user has manually responded to meeting request
     * @param resource $store user store
     * @param boolean $isDelegate true if delegate is processing this meeting request
     */
    function acceptException(&$recurringItem, &$occurrenceItem, $basedate, $move = false, $tentative, $userAction = false, $store, $isDelegate = false)
    {
        $recurr = new Recurrence($store, $recurringItem);

        // Copy properties from meeting request
        $exception_props = mapi_getprops($occurrenceItem);

        // Copy recipients list
        $reciptable = mapi_message_getrecipienttable($occurrenceItem);
        // If delegate, then do not add the delegate in recipients
        if ($isDelegate) {
            $delegate = mapi_getprops($this->message, array(PR_RECEIVED_BY_EMAIL_ADDRESS));
            $res = array(RES_PROPERTY, array(RELOP => RELOP_NE, ULPROPTAG => PR_EMAIL_ADDRESS, VALUE => $delegate[PR_RECEIVED_BY_EMAIL_ADDRESS]));
            $recips = mapi_table_queryallrows($reciptable, $this->recipprops, $res);
        } else {
            $recips = mapi_table_queryallrows($reciptable, $this->recipprops);
        }


        // add owner to recipient table
        $this->addOrganizer($exception_props, $recips, true);

        // add delegator to meetings
        if ($isDelegate) $this->addDelegator($exception_props, $recips);

        $exception_props[$this->proptags['meetingstatus']] = olMeetingReceived;
        $exception_props[$this->proptags['responsestatus']] = $userAction ? ($tentative ? olResponseTentative : olResponseAccepted) : olResponseNotResponded;
        // Set basedate property (ExceptionReplaceTime)

        if (isset($exception_props[$this->proptags['intendedbusystatus']])) {
            if($tentative && $exception_props[$this->proptags['intendedbusystatus']] !== fbFree) {
                $exception_props[$this->proptags['busystatus']] = $tentative;
            } else {
                $exception_props[$this->proptags['busystatus']] = $exception_props[$this->proptags['intendedbusystatus']];
            }
            // we already have intendedbusystatus value in $exception_props so no need to copy it
        } else {
            $exception_props[$this->proptags['busystatus']] = $tentative ? fbTentative : fbBusy;
        }

        if($userAction) {
            // if user has responded then set replytime
            $exception_props[$this->proptags['replytime']] = time();
        }

        if($recurr->isException($basedate))
            $recurr->modifyException($exception_props, $basedate, $recips, $occurrenceItem);
        else
            $recurr->createException($exception_props, $basedate, false, $recips, $occurrenceItem);

        // Move the occurrenceItem to the waste basket
        if ($move) {
            $wastebasket = $this->openDefaultWastebasket();
            $sourcefolder = mapi_msgstore_openentry($this->store, $exception_props[PR_PARENT_ENTRYID]);
            mapi_folder_copymessages($sourcefolder, Array($exception_props[PR_ENTRYID]), $wastebasket, MESSAGE_MOVE);
        }

        mapi_savechanges($recurringItem);
    }

    /**
     * Function which submits meeting request based on arguments passed to it.
     *@param resource $message MAPI_message whose meeting request is to be send
     *@param boolean $cancel if true send request, else send cancellation
     *@param string $prefix subject prefix
     *@param integer $basedate basedate for an occurrence
     *@param Object $recurObject recurrence object of mr
     *@param boolean $copyExceptions When sending update mail for recurring item then we dont send exceptions in attachments
     */
    function submitMeetingRequest($message, $cancel, $prefix, $basedate = false, $recurObject = false, $copyExceptions = true, $deletedRecips = false)
    {
        $newmessageprops = $messageprops = mapi_getprops($this->message);
        $new = $this->createOutgoingMessage();

        // Copy the entire message into the new meeting request message
        if ($basedate) {
            // messageprops contains properties of whole recurring series
            // and newmessageprops contains properties of exception item
            $newmessageprops = mapi_getprops($message);

            // Ensure that the correct basedate is set in the new message
            $newmessageprops[$this->proptags['basedate']] = $basedate;

            // Set isRecurring to false, because this is an exception
            $newmessageprops[$this->proptags['recurring']] = false;

            // set LID_IS_EXCEPTION to true
            $newmessageprops[$this->proptags['is_exception']] = true;

            // Set to high importance
            if($cancel) $newmessageprops[PR_IMPORTANCE] = IMPORTANCE_HIGH;

            // Set startdate and enddate of exception
            if ($cancel && $recurObject) {
                $newmessageprops[$this->proptags['startdate']] = $recurObject->getOccurrenceStart($basedate);
                $newmessageprops[$this->proptags['duedate']] = $recurObject->getOccurrenceEnd($basedate);
            }

            // Set basedate in guid (0x3)
            $newmessageprops[$this->proptags['goid']] = $this->setBasedateInGlobalID($messageprops[$this->proptags['goid2']], $basedate);
            $newmessageprops[$this->proptags['goid2']] = $messageprops[$this->proptags['goid2']];
            $newmessageprops[PR_OWNER_APPT_ID] = $messageprops[PR_OWNER_APPT_ID];

            // Get deleted recipiets from exception msg
            $restriction = Array(RES_AND,
                            Array(
                                Array(RES_BITMASK,
                                    Array(    ULTYPE        =>    BMR_NEZ,
                                            ULPROPTAG    =>    PR_RECIPIENT_FLAGS,
                                            ULMASK        =>    recipExceptionalDeleted
                                    )
                                ),
                                Array(RES_BITMASK,
                                    Array(    ULTYPE        =>    BMR_EQZ,
                                            ULPROPTAG    =>    PR_RECIPIENT_FLAGS,
                                            ULMASK        =>    recipOrganizer
                                    )
                                ),
                            )
            );

            // In direct-booking mode, we don't need to send cancellations to resources
            if($this->enableDirectBooking) {
                $restriction[1][] = Array(RES_PROPERTY,
                                        Array(RELOP => RELOP_NE,    // Does not equal recipient type: MAPI_BCC (Resource)
                                            ULPROPTAG => PR_RECIPIENT_TYPE,
                                            VALUE => array(PR_RECIPIENT_TYPE => MAPI_BCC)
                                        )
                                    );
            }

            $recipienttable = mapi_message_getrecipienttable($message);
            $recipients = mapi_table_queryallrows($recipienttable, $this->recipprops, $restriction);

            if (!$deletedRecips) {
                $deletedRecips = array_merge(array(), $recipients);
            } else {
                $deletedRecips = array_merge($deletedRecips, $recipients);
            }
        }

        // Remove the PR_ICON_INDEX as it is not needed in the sent message and it also
        // confuses the Zarafa webaccess
        $newmessageprops[PR_ICON_INDEX] = null;
        $newmessageprops[PR_RESPONSE_REQUESTED] = true;

        // PR_START_DATE and PR_END_DATE will be used by outlook to show the position in the calendar
        $newmessageprops[PR_START_DATE] = $newmessageprops[$this->proptags['startdate']];
        $newmessageprops[PR_END_DATE] = $newmessageprops[$this->proptags['duedate']];

        // Set updatecounter/AppointmentSequenceNumber
        // get the value of latest updatecounter for the whole series and use it
        $newmessageprops[$this->proptags['updatecounter']] = $messageprops[$this->proptags['last_updatecounter']];

        $meetingTimeInfo = $this->getMeetingTimeInfo();

        if($meetingTimeInfo)
            $newmessageprops[PR_BODY] = $meetingTimeInfo;

        // Send all recurrence info in mail, if this is a recurrence meeting.
        if (isset($messageprops[$this->proptags['recurring']]) && $messageprops[$this->proptags['recurring']]) {
            if(!empty($messageprops[$this->proptags['recurring_pattern']])) {
                $newmessageprops[$this->proptags['recurring_pattern']] = $messageprops[$this->proptags['recurring_pattern']];
            }
            $newmessageprops[$this->proptags['recurrence_data']] = $messageprops[$this->proptags['recurrence_data']];
            $newmessageprops[$this->proptags['timezone_data']] = $messageprops[$this->proptags['timezone_data']];
            $newmessageprops[$this->proptags['timezone']] = $messageprops[$this->proptags['timezone']];

            if($recurObject) {
                $this->generateRecurDates($recurObject, $messageprops, $newmessageprops);
            }
        }

        if (isset($newmessageprops[$this->proptags['counter_proposal']])) {
            unset($newmessageprops[$this->proptags['counter_proposal']]);
        }

        // Prefix the subject if needed
        if ($prefix && isset($newmessageprops[PR_SUBJECT]))
            $newmessageprops[PR_SUBJECT] = $prefix . $newmessageprops[PR_SUBJECT];

        mapi_setprops($new, $newmessageprops);

        // Copy attachments
        $this->replaceAttachments($message, $new, $copyExceptions);

        // Retrieve only those recipient who should receive this meeting request.
        $stripResourcesRestriction = Array(RES_AND,
                                Array(
                                    Array(RES_BITMASK,
                                        Array(    ULTYPE        =>    BMR_EQZ,
                                                ULPROPTAG    =>    PR_RECIPIENT_FLAGS,
                                                ULMASK        =>    recipExceptionalDeleted
                                        )
                                    ),
                                    Array(RES_BITMASK,
                                        Array(    ULTYPE        =>    BMR_EQZ,
                                                ULPROPTAG    =>    PR_RECIPIENT_FLAGS,
                                                ULMASK        =>    recipOrganizer
                                        )
                                    ),
                                )
        );

        // In direct-booking mode, resources do not receive a meeting request
        if($this->enableDirectBooking) {
            $stripResourcesRestriction[1][] =
                                    Array(RES_PROPERTY,
                                        Array(RELOP => RELOP_NE,    // Does not equal recipient type: MAPI_BCC (Resource)
                                            ULPROPTAG => PR_RECIPIENT_TYPE,
                                            VALUE => array(PR_RECIPIENT_TYPE => MAPI_BCC)
                                        )
                                    );
        }

        $recipienttable = mapi_message_getrecipienttable($message);
        $recipients = mapi_table_queryallrows($recipienttable, $this->recipprops, $stripResourcesRestriction);

        if ($basedate && empty($recipients)) {
            // Retrieve full list
            $recipienttable = mapi_message_getrecipienttable($this->message);
            $recipients = mapi_table_queryallrows($recipienttable, $this->recipprops);

            // Save recipients in exceptions
            mapi_message_modifyrecipients($message, MODRECIP_ADD, $recipients);

            // Now retrieve only those recipient who should receive this meeting request.
            $recipients = mapi_table_queryallrows($recipienttable, $this->recipprops, $stripResourcesRestriction);
        }

        //@TODO: handle nonAcceptingResources
        /**
         * Add resource recipients that did not automatically accept the meeting request.
         * (note: meaning that they did not decline the meeting request)
         *//*
        for($i=0;$i<count($this->nonAcceptingResources);$i++){
            $recipients[] = $this->nonAcceptingResources[$i];
        }*/

        if(!empty($recipients)) {
            // Strip out the sender/"owner" recipient
            mapi_message_modifyrecipients($new, MODRECIP_ADD, $recipients);

            // Set some properties that are different in the sent request than
            // in the item in our calendar

            // we should store busystatus value to intendedbusystatus property, because busystatus for outgoing meeting request
            // should always be fbTentative
            $newmessageprops[$this->proptags['intendedbusystatus']] = isset($newmessageprops[$this->proptags['busystatus']]) ? $newmessageprops[$this->proptags['busystatus']] : $messageprops[$this->proptags['busystatus']];
            $newmessageprops[$this->proptags['busystatus']] = fbTentative; // The default status when not accepted
            $newmessageprops[$this->proptags['responsestatus']] = olResponseNotResponded; // The recipient has not responded yet
            $newmessageprops[$this->proptags['attendee_critical_change']] = time();
            $newmessageprops[$this->proptags['owner_critical_change']] = time();
            $newmessageprops[$this->proptags['meetingtype']] = mtgRequest;

            if ($cancel) {
                $newmessageprops[PR_MESSAGE_CLASS] = "IPM.Schedule.Meeting.Canceled";
                $newmessageprops[$this->proptags['meetingstatus']] = olMeetingCanceled; // It's a cancel request
                $newmessageprops[$this->proptags['busystatus']] = fbFree; // set the busy status as free
            } else {
                $newmessageprops[PR_MESSAGE_CLASS] = "IPM.Schedule.Meeting.Request";
                $newmessageprops[$this->proptags['meetingstatus']] = olMeetingReceived; // The recipient is receiving the request
            }

            mapi_setprops($new, $newmessageprops);
            mapi_message_savechanges($new);

            // Submit message to non-resource recipients
            mapi_message_submitmessage($new);
        }

        // Send cancellation to deleted attendees
        if ($deletedRecips && !empty($deletedRecips)) {
            $new = $this->createOutgoingMessage();

            mapi_message_modifyrecipients($new, MODRECIP_ADD, $deletedRecips);

            $newmessageprops[PR_MESSAGE_CLASS] = "IPM.Schedule.Meeting.Canceled";
            $newmessageprops[$this->proptags['meetingstatus']] = olMeetingCanceled; // It's a cancel request
            $newmessageprops[$this->proptags['busystatus']] = fbFree; // set the busy status as free
            $newmessageprops[PR_IMPORTANCE] = IMPORTANCE_HIGH;    // HIGH Importance
            if (isset($newmessageprops[PR_SUBJECT])) {
                $newmessageprops[PR_SUBJECT] = _('Canceled: ') . $newmessageprops[PR_SUBJECT];
            }

            mapi_setprops($new, $newmessageprops);
            mapi_message_savechanges($new);

            // Submit message to non-resource recipients
            mapi_message_submitmessage($new);
        }

        // Set properties on meeting object in calendar
        // Set requestsent to 'true' (turns on 'tracking', etc)
        $props = array();
        $props[$this->proptags['meetingstatus']] = olMeeting;
        $props[$this->proptags['responsestatus']] = olResponseOrganized;
        $props[$this->proptags['requestsent']] = (!empty($recipients)) || ($this->includesResources && !$this->errorSetResource);
        $props[$this->proptags['attendee_critical_change']] = time();
        $props[$this->proptags['owner_critical_change']] = time();
        $props[$this->proptags['meetingtype']] = mtgRequest;
        // save the new updatecounter to exception/recurring series/normal meeting
        $props[$this->proptags['updatecounter']] = $newmessageprops[$this->proptags['updatecounter']];

        // PR_START_DATE and PR_END_DATE will be used by outlook to show the position in the calendar
        $props[PR_START_DATE] = $messageprops[$this->proptags['startdate']];
        $props[PR_END_DATE] = $messageprops[$this->proptags['duedate']];

        mapi_setprops($message, $props);

        // saving of these properties on calendar item should be handled by caller function
        // based on sending meeting request was successfull or not
    }

    /**
     * OL2007 uses these 4 properties to specify occurence that should be updated.
     * ical generates RECURRENCE-ID property based on exception's basedate (PidLidExceptionReplaceTime),
     * but OL07 doesn't send this property, so ical will generate RECURRENCE-ID property based on date
     * from GlobalObjId and time from StartRecurTime property, so we are sending basedate property and
     * also additionally we are sending these properties.
     * Ref: MS-OXCICAL 2.2.1.20.20 Property: RECURRENCE-ID
     * @param Object $recurObject instance of recurrence class for this message
     * @param Array $messageprops properties of meeting object that is going to be send
     * @param Array $newmessageprops properties of meeting request/response that is going to be send
     */
    function generateRecurDates($recurObject, $messageprops, &$newmessageprops)
    {
        if($messageprops[$this->proptags['startdate']] && $messageprops[$this->proptags['duedate']]) {
            $startDate = date("Y:n:j:G:i:s", $recurObject->fromGMT($recurObject->tz, $messageprops[$this->proptags['startdate']]));
            $endDate = date("Y:n:j:G:i:s", $recurObject->fromGMT($recurObject->tz, $messageprops[$this->proptags['duedate']]));

            $startDate = explode(":", $startDate);
            $endDate = explode(":", $endDate);

            // [0] => year, [1] => month, [2] => day, [3] => hour, [4] => minutes, [5] => seconds
            // RecurStartDate = year * 512 + month_number * 32 + day_number
            $newmessageprops[$this->proptags["start_recur_date"]] = (((int) $startDate[0]) * 512) + (((int) $startDate[1]) * 32) + ((int) $startDate[2]);
            // RecurStartTime = hour * 4096 + minutes * 64 + seconds
            $newmessageprops[$this->proptags["start_recur_time"]] = (((int) $startDate[3]) * 4096) + (((int) $startDate[4]) * 64) + ((int) $startDate[5]);

            $newmessageprops[$this->proptags["end_recur_date"]] = (((int) $endDate[0]) * 512) + (((int) $endDate[1]) * 32) + ((int) $endDate[2]);
            $newmessageprops[$this->proptags["end_recur_time"]] = (((int) $endDate[3]) * 4096) + (((int) $endDate[4]) * 64) + ((int) $endDate[5]);
        }
    }

    function createOutgoingMessage()
    {
        $sentprops = array();
        $outbox = $this->openDefaultOutbox($this->openDefaultStore());

        $outgoing = mapi_folder_createmessage($outbox);
        if(!$outgoing) return false;

        $addrinfo = $this->getOwnerAddress($this->store);
        if($addrinfo) {
            list($ownername, $owneremailaddr, $owneraddrtype, $ownerentryid, $ownersearchkey) = $addrinfo;
            $sentprops[PR_SENT_REPRESENTING_EMAIL_ADDRESS] = $owneremailaddr;
            $sentprops[PR_SENT_REPRESENTING_NAME] = $ownername;
            $sentprops[PR_SENT_REPRESENTING_ADDRTYPE] = $owneraddrtype;
            $sentprops[PR_SENT_REPRESENTING_ENTRYID] = $ownerentryid;
            $sentprops[PR_SENT_REPRESENTING_SEARCH_KEY] = $ownersearchkey;
        }

        $sentprops[PR_SENTMAIL_ENTRYID] = $this->getDefaultSentmailEntryID($this->openDefaultStore());

        mapi_setprops($outgoing, $sentprops);

        return $outgoing;
    }

    /**
     * Function which checks received meeting request is either old(outofdate) or new.
     * @return boolean true if meeting request is outofdate else false if it is new
     */
    function isMeetingOutOfDate()
    {
        $result = false;
        $store = $this->store;
        $props = mapi_getprops($this->message, array($this->proptags['goid'], $this->proptags['goid2'], $this->proptags['updatecounter'], $this->proptags['meetingtype'], $this->proptags['owner_critical_change']));

        if (isset($props[$this->proptags['meetingtype']]) && ($props[$this->proptags['meetingtype']] & mtgOutOfDate) == mtgOutOfDate) {
            return true;
        }

        // get the basedate to check for exception
        $basedate = $this->getBasedateFromGlobalID($props[$this->proptags['goid']]);

        $calendarItems = $this->getCorrespondedCalendarItems();

        foreach($calendarItems as $calendarItem) {
            if ($calendarItem) {
                $calendarItemProps = mapi_getprops($calendarItem, array(
                                                        $this->proptags['owner_critical_change'],
                                                        $this->proptags['updatecounter'],
                                                        $this->proptags['recurring']
                                        ));

                // If these items is recurring and basedate is found then open exception to compare it with meeting request
                if (isset($calendarItemProps[$this->proptags['recurring']]) && $calendarItemProps[$this->proptags['recurring']] && $basedate) {
                    $recurr = new Recurrence($store, $calendarItem);

                    if ($recurr->isException($basedate)) {
                        $attach = $recurr->getExceptionAttachment($basedate);
                        $exception = mapi_attach_openobj($attach, 0);
                        $occurrenceItemProps = mapi_getprops($exception, array(
                                                        $this->proptags['owner_critical_change'],
                                                        $this->proptags['updatecounter']
                                            ));
                    }

                    // we found the exception, compare with it
                    if(isset($occurrenceItemProps)) {
                        if ((isset($occurrenceItemProps[$this->proptags['updatecounter']]) && $props[$this->proptags['updatecounter']] < $occurrenceItemProps[$this->proptags['updatecounter']])
                            || (isset($occurrenceItemProps[$this->proptags['owner_critical_change']]) && $props[$this->proptags['owner_critical_change']] < $occurrenceItemProps[$this->proptags['owner_critical_change']])) {

                            mapi_setprops($this->message, array($this->proptags['meetingtype'] => mtgOutOfDate, PR_ICON_INDEX => 1033));
                            mapi_savechanges($this->message);
                            $result = true;
                        }
                    } else {
                        // we are not able to find exception, could mean that a significant change has occured on series
                        // and it deleted all exceptions, so compare with series
                        if ((isset($calendarItemProps[$this->proptags['updatecounter']]) && $props[$this->proptags['updatecounter']] < $calendarItemProps[$this->proptags['updatecounter']])
                            || (isset($calendarItemProps[$this->proptags['owner_critical_change']]) && $props[$this->proptags['owner_critical_change']] < $calendarItemProps[$this->proptags['owner_critical_change']])) {

                            mapi_setprops($this->message, array($this->proptags['meetingtype'] => mtgOutOfDate, PR_ICON_INDEX => 1033));
                            mapi_savechanges($this->message);
                            $result = true;
                        }
                    }
                } else {
                    // normal / recurring series
                    if ((isset($calendarItemProps[$this->proptags['updatecounter']]) && $props[$this->proptags['updatecounter']] < $calendarItemProps[$this->proptags['updatecounter']])
                            || (isset($calendarItemProps[$this->proptags['owner_critical_change']]) && $props[$this->proptags['owner_critical_change']] < $calendarItemProps[$this->proptags['owner_critical_change']])) {

                        mapi_setprops($this->message, array($this->proptags['meetingtype'] => mtgOutOfDate, PR_ICON_INDEX => 1033));
                        mapi_savechanges($this->message);
                        $result = true;
                    }
                }
            }
        }

        return $result;
    }

    /**
     * Function which checks received meeting request is updated later or not.
     * @return boolean true if meeting request is updated later.
     * @TODO: Implement handling for recurrings and exceptions.
     */
    function isMeetingUpdated()
    {
        $result = false;
        $store = $this->store;
        $props = mapi_getprops($this->message, array($this->proptags['goid'], $this->proptags['goid2'], $this->proptags['updatecounter'], $this->proptags['owner_critical_change'], $this->proptags['updatecounter']));

        $calendarItems = $this->getCorrespondedCalendarItems();

        foreach($calendarItems as $calendarItem) {
            if ($calendarItem) {
                $calendarItemProps = mapi_getprops($calendarItem, array(
                                                    $this->proptags['updatecounter'],
                                                    $this->proptags['recurring']
                                    ));

                if(isset($calendarItemProps[$this->proptags['updatecounter']]) && isset($props[$this->proptags['updatecounter']]) && $calendarItemProps[$this->proptags['updatecounter']] > $props[$this->proptags['updatecounter']]) {
                    $result = true;
                }
            }
        }

        return $result;
    }

    /**
     * Checks if there has been any significant changes on appointment/meeting item.
     * Significant changes be:
     * 1) startdate has been changed
     * 2) duedate has been changed OR
     * 3) recurrence pattern has been created, modified or removed
     *
     * @param Array oldProps old props before an update
     * @param Number basedate basedate
     * @param Boolean isRecurrenceChanged for change in recurrence pattern.
     * isRecurrenceChanged true means Recurrence pattern has been changed, so clear all attendees response
     */
    function checkSignificantChanges($oldProps, $basedate, $isRecurrenceChanged = false)
    {
        $message = null;
        $attach = null;

        // If basedate is specified then we need to open exception message to clear recipient responses
        if($basedate) {
            $recurrence = new Recurrence($this->store, $this->message);
            if($recurrence->isException($basedate)){
                $attach = $recurrence->getExceptionAttachment($basedate);
                if ($attach) {
                    $message = mapi_attach_openobj($attach, MAPI_MODIFY);
                }
            }
        } else {
            // use normal message or recurring series message
            $message = $this->message;
        }

        if(!$message) {
            return;
        }

        $newProps = mapi_getprops($message, array($this->proptags['startdate'], $this->proptags['duedate'], $this->proptags['updatecounter']));

        // Check whether message is updated or not.
        if(isset($newProps[$this->proptags['updatecounter']]) && $newProps[$this->proptags['updatecounter']] == 0) {
            return;
        }

        if (($newProps[$this->proptags['startdate']] != $oldProps[$this->proptags['startdate']])
            || ($newProps[$this->proptags['duedate']] != $oldProps[$this->proptags['duedate']])
            || $isRecurrenceChanged) {
            $this->clearRecipientResponse($message);

            mapi_setprops($message, array($this->proptags['owner_critical_change'] => time()));

            mapi_savechanges($message);
            if ($attach) { // Also save attachment Object.
                mapi_savechanges($attach);
            }
        }
    }

    /**
     * Clear responses of all attendees who have replied in past.
     * @param MAPI_MESSAGE $message on which responses should be cleared
     */
    function clearRecipientResponse($message)
    {
        $recipTable = mapi_message_getrecipienttable($message);
        $recipsRows = mapi_table_queryallrows($recipTable, $this->recipprops);

        foreach($recipsRows as $recipient) {
            if(($recipient[PR_RECIPIENT_FLAGS] & recipOrganizer) != recipOrganizer){
                // Recipient is attendee, set the trackstatus to "Not Responded"
                $recipient[PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusNone;
            } else {
                // Recipient is organizer, this is not possible, but for safety
                // it is best to clear the trackstatus for him as well by setting
                // the trackstatus to "Organized".
                $recipient[PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusNone;
            }
            mapi_message_modifyrecipients($message, MODRECIP_MODIFY, array($recipient));
        }
    }

    /**
     * Function returns corresponded calendar items attached with
     * the meeting request.
     * @return Array array of correlated calendar items.
     */
    function getCorrespondedCalendarItems()
    {
        $store = $this->store;
        $props = mapi_getprops($this->message, array($this->proptags['goid'], $this->proptags['goid2'], PR_RCVD_REPRESENTING_NAME));

        $basedate = $this->getBasedateFromGlobalID($props[$this->proptags['goid']]);

        // If Delegate is processing mr for Delegator then retrieve Delegator's store and calendar.
        if (isset($props[PR_RCVD_REPRESENTING_NAME])) {
            $delegatorStore = $this->getDelegatorStore($props);
            $store = $delegatorStore['store'];
            $calFolder = $delegatorStore['calFolder'];
        } else {
            $calFolder = $this->openDefaultCalendar();
        }

        // Finding item in calendar with GlobalID(0x3), not necessary that attendee is having recurring item, he/she can also have only a occurrence
        $entryids = $this->findCalendarItems($props[$this->proptags['goid']], $calFolder);

        // Basedate found, so this meeting request is an update of an occurrence.
        if ($basedate) {
            if (!$entryids) {
                // Find main recurring item in calendar with GlobalID(0x23)
                $entryids = $this->findCalendarItems($props[$this->proptags['goid2']], $calFolder);
            }
        }

        $calendarItems = array();
        if ($entryids) {
            foreach($entryids as $entryid) {
                $calendarItems[] = mapi_msgstore_openentry($store, $entryid);
            }
        }

        return $calendarItems;
    }

    /**
     * Function which checks whether received meeting request is either conflicting with other appointments or not.
     *@return mixed(boolean/integer) true if normal meeting is conflicting or an integer which specifies no of instances
     * conflict of recurring meeting and false if meeting is not conflicting.
     */
    function isMeetingConflicting($message = false, $userStore = false, $calFolder = false, $msgprops = false)
    {
        $returnValue = false;
        $conflicting = false;
        $noOfInstances = 0;

        if (!$message) $message = $this->message;

        if (!$userStore) $userStore = $this->store;

        if (!$calFolder) {
            $root = mapi_msgstore_openentry($userStore);
            $rootprops = mapi_getprops($root, array(PR_STORE_ENTRYID, PR_IPM_APPOINTMENT_ENTRYID, PR_FREEBUSY_ENTRYIDS));

            if(!isset($rootprops[PR_IPM_APPOINTMENT_ENTRYID])) {
                return;
            }

            $calFolder = mapi_msgstore_openentry($userStore, $rootprops[PR_IPM_APPOINTMENT_ENTRYID]);
        }

        if (!$msgprops) $msgprops = mapi_getprops($message, array($this->proptags['goid'], $this->proptags['goid2'], $this->proptags['startdate'], $this->proptags['duedate'], $this->proptags['recurring'], $this->proptags['clipstart'], $this->proptags['clipend']));

        if ($calFolder) {
            // Meeting request is recurring, so get all occurrence and check for each occurrence whether it conflicts with other appointments in Calendar.
            if (isset($msgprops[$this->proptags['recurring']]) && $msgprops[$this->proptags['recurring']]) {
                // Apply recurrence class and retrieve all occurrences(max: 30 occurrence because recurrence can also be set as 'no end date')
                $recurr = new Recurrence($userStore, $message);
                $items = $recurr->getItems($msgprops[$this->proptags['clipstart']], $msgprops[$this->proptags['clipend']] * (24*24*60), 30);

                foreach ($items as $item) {
                    // Get all items in the timeframe that we want to book, and get the goid and busystatus for each item
                    $calendarItems = $recurr->getCalendarItems($userStore, $calFolder, $item[$this->proptags['startdate']], $item[$this->proptags['duedate']], array($this->proptags['goid'], $this->proptags['busystatus'], PR_OWNER_APPT_ID));

                    foreach ($calendarItems as $calendarItem) {
                        if ($calendarItem[$this->proptags['busystatus']] != fbFree) {
                            /**
                             * Only meeting requests have globalID, normal appointments do not have globalID
                             * so if any normal appointment if found then it is assumed to be conflict.
                             */
                            if(isset($calendarItem[$this->proptags['goid']])) {
                                if ($calendarItem[$this->proptags['goid']] !== $msgprops[$this->proptags['goid']]) {
                                    $noOfInstances++;
                                    break;
                                }
                            } else {
                                $noOfInstances++;
                                break;
                            }
                        }
                    }
                }

                $returnValue = $noOfInstances;
            } else {
                // Get all items in the timeframe that we want to book, and get the goid and busystatus for each item
                $items = getCalendarItems($userStore, $calFolder, $msgprops[$this->proptags['startdate']], $msgprops[$this->proptags['duedate']], array($this->proptags['goid'], $this->proptags['busystatus'], PR_OWNER_APPT_ID));

                foreach($items as $item) {
                    if ($item[$this->proptags['busystatus']] != fbFree) {
                        if(isset($item[$this->proptags['goid']])) {
                            if (($item[$this->proptags['goid']] !== $msgprops[$this->proptags['goid']])
                                && ($item[$this->proptags['goid']] !== $msgprops[$this->proptags['goid2']])) {
                                $conflicting = true;
                                break;
                            }
                        } else {
                            $conflicting = true;
                            break;
                        }
                    }
                }

                if ($conflicting) $returnValue = true;
            }
        }
        return $returnValue;
    }

    /**
     *  Function which adds organizer to recipient list which is passed.
     *  This function also checks if it has organizer.
     *
     * @param array $messageProps message properties
     * @param array $recipients    recipients list of message.
     * @param boolean $isException true if we are processing recipient of exception
     */
    function addDelegator($messageProps, &$recipients)
    {
        $hasDelegator = false;
        // Check if meeting already has an organizer.
        foreach ($recipients as $key => $recipient){
            if (isset($messageProps[PR_RCVD_REPRESENTING_EMAIL_ADDRESS]) && $recipient[PR_EMAIL_ADDRESS] == $messageProps[PR_RCVD_REPRESENTING_EMAIL_ADDRESS])
                $hasDelegator = true;
        }

        if (!$hasDelegator){
            // Create delegator.
            $delegator = array();
            $delegator[PR_ENTRYID] = $messageProps[PR_RCVD_REPRESENTING_ENTRYID];
            $delegator[PR_DISPLAY_NAME] = $messageProps[PR_RCVD_REPRESENTING_NAME];
            $delegator[PR_EMAIL_ADDRESS] = $messageProps[PR_RCVD_REPRESENTING_EMAIL_ADDRESS];
            $delegator[PR_RECIPIENT_TYPE] = MAPI_TO;
            $delegator[PR_RECIPIENT_DISPLAY_NAME] = $messageProps[PR_RCVD_REPRESENTING_NAME];
            $delegator[PR_ADDRTYPE] = empty($messageProps[PR_RCVD_REPRESENTING_ADDRTYPE]) ? 'SMTP':$messageProps[PR_RCVD_REPRESENTING_ADDRTYPE];
            $delegator[PR_RECIPIENT_TRACKSTATUS] = olRecipientTrackStatusNone;
            $delegator[PR_RECIPIENT_FLAGS] = recipSendable;

            // Add organizer to recipients list.
            array_unshift($recipients, $delegator);
        }
    }

    function getDelegatorStore($messageprops)
    {
        // Find the organiser of appointment in addressbook
        $delegatorName = array(array(PR_DISPLAY_NAME => $messageprops[PR_RCVD_REPRESENTING_NAME]));
        $ab = mapi_openaddressbook($this->session);
        $user = mapi_ab_resolvename($ab, $delegatorName, EMS_AB_ADDRESS_LOOKUP);

        // Get StoreEntryID by username
        $delegatorEntryid = mapi_msgstore_createentryid($this->store, $user[0][PR_EMAIL_ADDRESS]);
        // Open store of the delegator
        $delegatorStore = mapi_openmsgstore($this->session, $delegatorEntryid);
        // Open root folder
        $delegatorRoot = mapi_msgstore_openentry($delegatorStore, null);
        // Get calendar entryID
        $delegatorRootProps = mapi_getprops($delegatorRoot, array(PR_IPM_APPOINTMENT_ENTRYID));
        // Open the calendar Folder
        $calFolder = mapi_msgstore_openentry($delegatorStore, $delegatorRootProps[PR_IPM_APPOINTMENT_ENTRYID]);

        return Array('store' => $delegatorStore, 'calFolder' => $calFolder);
    }

    /**
     * Function returns extra info about meeting timing along with message body
     * which will be included in body while sending meeting request/response.
     *
     * @return string $meetingTimeInfo info about meeting timing along with message body
     */
    function getMeetingTimeInfo()
    {
        return $this->meetingTimeInfo;
    }

    /**
     * Function sets extra info about meeting timing along with message body
     * which will be included in body while sending meeting request/response.
     *
     * @param string $meetingTimeInfo info about meeting timing along with message body
     */
    function setMeetingTimeInfo($meetingTimeInfo)
    {
        $this->meetingTimeInfo = $meetingTimeInfo;
    }
}
?>