Examples with EventContainer org.openhab.io.caldav.internal.EventStorage.EventContainer used on opensource projects

Example 6 with EventContainer

use of org.openhab.io.caldav.internal.EventStorage.EventContainer in project openhab1-addons by openhab.

the class EventReloaderJob method loadEvents.

/**
     * all events which are available must be removed from the oldEventIds list
     *
     * @param calendarRuntime
     * @param oldEventIds
     * @throws IOException
     * @throws ParserException
     */
public synchronized void loadEvents(final CalendarRuntime calendarRuntime, final List<String> oldEventIds) throws IOException, ParserException {
    CalDavConfig config = calendarRuntime.getConfig();
    Sardine sardine = Util.getConnection(config);
    List<DavResource> list = sardine.list(config.getUrl(), 1, false);
    log.trace("before load events : oldeventsid contains : {}", oldEventIds.toString());
    for (DavResource resource : list) {
        final String filename = Util.getFilename(resource.getName());
        try {
            if (resource.isDirectory()) {
                continue;
            }
            // an ics file can contain multiple events
            // ==> multiple eventcontainers could have the same filename (and different eventid),
            // ==>we must not have one of them remaining in oldEventIds var (bad chosen name, cause it's a list of
            // oldEventContainers's filename, so with doubles possible)
            // or the remaining jobs with this filename will get unscheduled on the "removeDeletedEvents(config,
            // oldEventIds)" call (line 136)
            oldEventIds.removeAll(Arrays.asList(filename));
            // must not be loaded
            EventContainer eventContainer = calendarRuntime.getEventContainerByFilename(filename);
            final org.joda.time.DateTime lastResourceChangeFS = new org.joda.time.DateTime(resource.getModified());
            log.trace("eventContainer found: {}", eventContainer != null);
            log.trace("last resource modification: {}", lastResourceChangeFS);
            log.trace("last change of already loaded event: {}", eventContainer != null ? eventContainer.getLastChanged() : null);
            if (config.isLastModifiedFileTimeStampValid()) {
                if (eventContainer != null && !lastResourceChangeFS.isAfter(eventContainer.getLastChanged())) {
                    // to be created
                    if (eventContainer.getCalculatedUntil() != null && eventContainer.getCalculatedUntil().isAfter(org.joda.time.DateTime.now().plusMinutes(config.getReloadMinutes()))) {
                        // the event is calculated as long as the next reload
                        // interval can handle this
                        log.trace("skipping resource {}, not changed (calculated until: {})", resource.getName(), eventContainer.getCalculatedUntil());
                        continue;
                    }
                    if (eventContainer.isHistoricEvent()) {
                        // no more upcoming events, do nothing
                        log.trace("skipping resource {}, not changed (historic)", resource.getName());
                        continue;
                    }
                    File icsFile = Util.getCacheFile(config.getKey(), filename);
                    if (icsFile != null && icsFile.exists()) {
                        FileInputStream fis = new FileInputStream(icsFile);
                        this.loadEvents(filename, lastResourceChangeFS, fis, config, oldEventIds, false);
                        fis.close();
                        continue;
                    }
                }
            }
            log.debug("loading resource: {} (FSchangedTS not valid)", resource);
            // prepare resource url
            URL url = new URL(config.getUrl());
            String resourcePath = resource.getPath();
            String escapedResource = resource.getName().replaceAll("/", "%2F");
            resourcePath = resourcePath.replace(resource.getName(), escapedResource);
            url = new URL(url.getProtocol(), url.getHost(), url.getPort(), resourcePath);
            InputStream inputStream = sardine.get(url.toString().replaceAll(" ", "%20"));
            this.loadEvents(filename, lastResourceChangeFS, inputStream, config, oldEventIds, false);
        } catch (ParserException e) {
            log.error("error parsing ics file: " + filename, e);
        } catch (SardineException e) {
            log.error("error reading ics file: " + filename, e);
        }
    }
    log.trace("after load events : oldeventsid contains : {}", oldEventIds.toString());
}

Example 7 with EventContainer

use of org.openhab.io.caldav.internal.EventStorage.EventContainer in project openhab1-addons by openhab.

the class CalDavLoaderImpl method getEvents.

@Override
public List<CalDavEvent> getEvents(final CalDavQuery query) {
    log.trace("quering events for filter: {}", query);
    final ArrayList<CalDavEvent> eventList = new ArrayList<CalDavEvent>();
    if (query.getCalendarIds() != null) {
        for (String calendarId : query.getCalendarIds()) {
            final CalendarRuntime eventRuntime = EventStorage.getInstance().getEventCache().get(calendarId);
            if (eventRuntime == null) {
                log.debug("calendar id {} not found", calendarId);
                continue;
            }
            for (EventContainer eventContainer : eventRuntime.getEventMap().values()) {
                for (CalDavEvent calDavEvent : eventContainer.getEventList()) {
                    if (query.getFrom() != null) {
                        if (calDavEvent.getEnd().isBefore(query.getFrom())) {
                            continue;
                        }
                    }
                    if (query.getTo() != null) {
                        if (calDavEvent.getStart().isAfter(query.getTo())) {
                            continue;
                        }
                    }
                    if (query.getFilterName() != null) {
                        if (!calDavEvent.getName().matches(query.getFilterName())) {
                            continue;
                        }
                    }
                    if (query.getFilterCategory() != null) {
                        log.trace("processing filter category");
                        if (calDavEvent.getCategoryList() == null) {
                            log.trace("not found event category for event {}", calDavEvent.getId());
                            continue;
                        } else {
                            log.trace("processing event category");
                            boolean eventCategoriesMatchFilterCategories = false;
                            if (query.getFilterCategoryMatchesAny()) {
                                log.trace("filter-category-any encountered");
                                int filterCategoriesIndex = 0;
                                List<String> filterCategories = query.getFilterCategory();
                                List<String> eventCategories = calDavEvent.getCategoryList();
                                log.trace("comparing filter '{}' to event categories '{}' from event {}", filterCategories, eventCategories, calDavEvent.getId());
                                // browse filter categories, which are not null
                                while (eventCategoriesMatchFilterCategories == false && filterCategoriesIndex < filterCategories.size()) {
                                    int eventCategoriesIndex = 0;
                                    // browse event categories, which can be null
                                    while (eventCategoriesMatchFilterCategories == false && eventCategoriesIndex < eventCategories.size()) {
                                        if (eventCategories.get(eventCategoriesIndex).equalsIgnoreCase(filterCategories.get(filterCategoriesIndex))) {
                                            log.debug("filter category {} matches event category {}", filterCategories.get(filterCategoriesIndex), eventCategories.get(eventCategoriesIndex));
                                            eventCategoriesMatchFilterCategories = true;
                                        }
                                        eventCategoriesIndex++;
                                    }
                                    filterCategoriesIndex++;
                                }
                            } else {
                                log.trace("filter-category encountered");
                                eventCategoriesMatchFilterCategories = calDavEvent.getCategoryList().containsAll(query.getFilterCategory());
                            }
                            if (!eventCategoriesMatchFilterCategories) {
                                continue;
                            }
                        }
                    } else {
                        log.trace("not found any filter category");
                    }
                    eventList.add(calDavEvent);
                }
            }
        }
    }
    if (query.getSort() != null) {
        Collections.sort(eventList, new Comparator<CalDavEvent>() {

            @Override
            public int compare(CalDavEvent arg0, CalDavEvent arg1) {
                if (query.getSort().equals(CalDavQuery.Sort.ASCENDING)) {
                    return (arg0.getStart().compareTo(arg1.getStart()));
                } else if (query.getSort().equals(CalDavQuery.Sort.DESCENDING)) {
                    return (arg1.getStart().compareTo(arg0.getStart()));
                } else {
                    return 0;
                }
            }
        });
    }
    log.debug("return event list for {} with {} entries", query, eventList.size());
    return eventList;
}

Example 8 with EventContainer

use of org.openhab.io.caldav.internal.EventStorage.EventContainer in project openhab1-addons by openhab.

the class EventJob method execute.

@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
    try {
        final String config = context.getJobDetail().getJobDataMap().getString(KEY_CONFIG);
        final String eventId = context.getJobDetail().getJobDataMap().getString(KEY_EVENT);
        final int recIndex = context.getJobDetail().getJobDataMap().getInt(KEY_REC_INDEX);
        final EventTrigger eventTrigger = EventTrigger.valueOf(context.getJobDetail().getJobDataMap().getString(KEY_EVENT_TRIGGER));
        CalendarRuntime calendarRuntime = EventStorage.getInstance().getEventCache().get(config);
        if (calendarRuntime == null) {
            throw new JobExecutionException("cannot get runtime for config: " + config, false);
        }
        EventContainer eventContainer = calendarRuntime.getEventMap().get(eventId);
        if (eventContainer == null) {
            throw new JobExecutionException("cannot get event-container for config: " + config + " and eventId: " + eventId, false);
        }
        if (eventContainer.getEventList().size() <= recIndex) {
            throw new JobExecutionException("cannot get recurence-event for config: " + config + " and eventId: " + eventId + " and occurence: " + recIndex, false);
        }
        CalDavEvent event = eventContainer.getEventList().get(recIndex);
        log.info("event {} for: {}", eventTrigger, event.getShortName());
        for (EventNotifier notifier : CalDavLoaderImpl.instance.getEventListenerList()) {
            try {
                if (eventTrigger == EventTrigger.BEGIN) {
                    notifier.eventBegins(event);
                } else if (eventTrigger == EventTrigger.END) {
                    notifier.eventEnds(event);
                } else {
                    throw new IllegalStateException("not implemented event trigger: " + eventTrigger);
                }
            } catch (Exception e) {
                log.error("error while invoking listener", e);
            }
        }
        if (eventTrigger == EventTrigger.END) {
            // if event is ended, remove it from the map
            calendarRuntime.getEventMap().remove(eventContainer.getEventId());
        }
    } catch (Exception e) {
        log.error("error executing event job", e);
        throw new JobExecutionException("error executing event job", e, false);
    }
}