def fetch_rsv_from_cal(room, curr_motion_time, occupied_pct, callback=None):
    
    rc = None
    for r in ReaperConfig.objects.all():
        rc = r
        break
    
    #initialize google calendar api
    gcal = GCalendar(rc.g_consumer_key, rc.g_consumer_secret, rc.g_admin_user_email, rc.g_developer_key)
    
    if not gcal:
        print("Google Calendar API not initialized")
        return None

    #Get reservation if found at current time.     
    #event = gcal.getCurrentEventFromCalendar(room['calendar_id'])
    (event, next_event) = gcal.getCurrentOrNextEventFromCalendar(room['calendar_id'])
    
    if event and event.has_key('id'):
        rsv_status=True
    else:
        rsv_status=False
        
    print ("fetch_rsv_from_cal --> room_id: %d curr_motion_time: %r rsv_status: %d" 
                %(room['room_id'], curr_motion_time, rsv_status))
    
    
    if callback:
        subtask(callback).delay(room, rsv_status, event, curr_motion_time, occupied_pct, next_event)
        
    return rsv_status
def reap(room, rsv_status, event, curr_motion_time, occupied_pct, next_event):
    print ("reap --> room_id: %d curr_motion_time: %r rsv_status: %d occ_pct %f" 
                %(room['room_id'], curr_motion_time, rsv_status, occupied_pct))
    current_time = timezone.now()
    print "current time (UTC): %r" %(current_time)
    
    #get timeout from reaperconfig
    reaper_config = None
    for r in ReaperConfig.objects.all():
        reaper_config = r
        break
    
    
    #if api did not return motion time for some reason, then set it to current time
    #to prevent greedy reaps
    
    if not curr_motion_time:
        curr_motion_time = current_time
    
    #calculate vacant_secs
    if curr_motion_time:        
        vacant_secs = get_pos_time_diff_secs(current_time, curr_motion_time)
    else:
        vacant_secs = None
            
    #Calculate occ_status
    #vacant_secs > 120 secs, occ_status = False
    #if vacant_secs > 10:
    if vacant_secs > OCC_THRESHOLD:
        occ_status = False
    else:
        occ_status = True
        
    
    #Reaper Logic    
    time_to_reap = None
    reaped = False
    avail_until = None
    if rsv_status:
        occ_timeout_secs = reaper_config.occ_motion_timeout * 60
        event_start_secs = get_pos_time_diff_secs(current_time,event['start_time'])
        print "occ_timeout_secs: %f vacant_secs: %f sec_fr_event_start: %f" %(occ_timeout_secs, vacant_secs, event_start_secs)
        
        time_to_reap = None
        reaped = False
        
        #use the smaller number as the comparator
        if vacant_secs < event_start_secs:
            cmp_secs = vacant_secs 
        else:
            cmp_secs = event_start_secs
        
        # wait till occ_timeout_secs from vacant time or from start of meeting which ever is less
        if (cmp_secs >= occ_timeout_secs):
            print "OK to reap"
            time_to_reap = 0        
            #initialize google calendar api
            gcal = GCalendar(reaper_config.g_consumer_key, reaper_config.g_consumer_secret, 
                             reaper_config.g_admin_user_email, reaper_config.g_developer_key)
    
            if not gcal:
                print("Google Calendar API not initialized")
                return None
            
            reaped = gcal.deleteEventFromCalendar(room['calendar_id'], event['id'], send_notification=True)
            occ_status=False  #just in case
            rsv_status=False        
        else:
            time_to_reap = occ_timeout_secs - cmp_secs

        if time_to_reap:        
            print "time_to_reap: %f" %(time_to_reap)
        else:
            print "time_to_reap: None"
            
    
    #room is available till next event
    if next_event and 'start_time' in next_event:
        avail_until = next_event['start_time']

    #Update room status
    if rsv_status and not reaped:
        booked_until = None
        if event.has_key('booked_until'):
            booked_until = event['booked_until']
        else:
            booked_until = event['end_time']
            
        update_room_status(room,
                             occupied = occ_status,
                             reserved = rsv_status,
                             last_motion_ts = curr_motion_time,
                             last_checked_ts = current_time,
                             time_to_reap = time_to_reap,
                             vacant_secs = vacant_secs,
                             occupancy_pct = occupied_pct,
                             booked_until = booked_until,
                             avail_until = None,
                             rsv_begin_time = event['start_time'],
                             rsv_end_time = event['end_time'],
                             rsv_owner_email = event['owner_email'],
                             rsv_owner_name = event['owner_name'],
                             event_timezone = event['timezone'],
                             allow_res=False
                            )
    else:
        update_room_status(room,
                             occupied = occ_status,
                             reserved = rsv_status,
                             last_motion_ts = curr_motion_time,
                             last_checked_ts = current_time,
                             time_to_reap = None,
                             vacant_secs = None,
                             occupancy_pct = occupied_pct,
                             booked_until = None,
                             avail_until = avail_until,
                             rsv_begin_time = None,
                             rsv_end_time = None,
                             rsv_owner_email = None,
                             rsv_owner_name = None,
                             event_timezone = None,
                             allow_res=True
                            )    
        
    #Notify on cancellation and write to log
    if reaped:
        notify_on_event.subtask().delay(room,event,action='CANCEL_RSV')