Kolab Groupware OBS

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 5

roundcubemail.spec Changed

buildroundcubemailtarball.sh Changed

roundcubemail-1.5.3.tar.gz/plugins/calendar/calendar_ui.js Changed

roundcubemail-1.5.3.tar.gz/plugins/calendar/config.inc.php Changed

roundcubemail-1.5.3.tar.gz/plugins/calendar/config.inc.php.dist Changed

roundcubemail-1.5.3.tar.gz/plugins/calendar/drivers/caldav Added

roundcubemail-1.5.3.tar.gz/plugins/calendar/drivers/caldav/caldav_calendar.php Added

@@ -0,0 +1,904 @@
+<?php
+
+/**
+ * CalDAV calendar storage class
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2012-2022, Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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 caldav_calendar extends kolab_storage_dav_folder
+{
+    public $ready         = false;
+    public $rights        = 'lrs';
+    public $editable      = false;
+    public $attachments   = false; // TODO
+    public $alarms        = false;
+    public $history       = false;
+    public $subscriptions = false;
+    public $categories    = ;
+    public $storage;
+
+    public $type = 'event';
+
+    protected $cal;
+    protected $events = ;
+    protected $search_fields = 'title', 'description', 'location', 'attendees', 'categories';
+
+    /**
+     * Factory method to instantiate a caldav_calendar object
+     *
+     * @param string $id       Calendar ID (encoded IMAP folder name)
+     * @param object $calendar Calendar plugin object
+     *
+     * @return caldav_calendar Self instance
+     */
+    public static function factory($id, $calendar)
+    {
+        return new caldav_calendar($id, $calendar);
+    }
+
+    /**
+     * Default constructor
+     */
+    public function __construct($folder_or_id, $calendar)
+    {
+        if ($folder_or_id instanceof kolab_storage_dav_folder) {
+            $this->storage = $folder_or_id;
+        }
+        else {
+        //    $this->storage = kolab_storage_dav::get_folder($folder_or_id);
+        }
+
+        $this->cal        = $calendar;
+        $this->id         = $this->storage->id;
+        $this->attributes = $this->storage->attributes;
+        $this->ready      = true;
+
+        // Set writeable and alarms flags according to folder permissions
+        if ($this->ready) {
+            if ($this->storage->get_namespace() == 'personal') {
+                $this->editable = true;
+                $this->rights = 'lrswikxteav';
+                $this->alarms = true;
+            }
+            else {
+                $rights = $this->storage->get_myrights();
+                if ($rights && !PEAR::isError($rights)) {
+                    $this->rights = $rights;
+                    if (strpos($rights, 't') !== false || strpos($rights, 'd') !== false) {
+                        $this->editable = strpos($rights, 'i');;
+                    }
+                }
+            }
+
+            // user-specific alarms settings win
+            $prefs = $this->cal->rc->config->get('kolab_calendars', );
+            if (isset($prefs$this->id'showalarms')) {
+                $this->alarms = $prefs$this->id'showalarms';
+            }
+        }
+
+        $this->default = $this->storage->default;
+        $this->subtype = $this->storage->subtype;
+    }
+
+    /**
+     * Getter for the folder name
+     *
+     * @return string Name of the folder
+     */
+    public function get_realname()
+    {
+        return $this->get_name();
+    }
+
+    /**
+     * Return color to display this calendar
+     */
+    public function get_color($default = null)
+    {
+        if ($color = $this->storage->get_color()) {
+            return $color;
+        }
+
+        return $default ?: 'cc0000';
+    }
+
+    /**
+     * Compose an URL for CalDAV access to this calendar (if configured)
+     */
+    public function get_caldav_url()
+    {
+/*
+        if ($template = $this->cal->rc->config->get('calendar_caldav_url', null)) {
+            return strtr($template, 
+                    '%h' => $_SERVER'HTTP_HOST',
+                    '%u' => urlencode($this->cal->rc->get_user_name()),
+                    '%i' => urlencode($this->storage->get_uid()),
+                    '%n' => urlencode($this->name),
+            );
+        }
+*/
+        return false;
+    }
+
+    /**
+     * Update properties of this calendar folder
+     *
+     * @see caldav_driver::edit_calendar()
+     */
+    public function update(&$prop)
+    {
+        // TODO
+        return null;
+    }
+
+    /**
+     * Getter for a single event object
+     */
+    public function get_event($id)
+    {
+        // remove our occurrence identifier if it's there
+        $master_id = preg_replace('/-\d{8}(T\d{6})?$/', '', $id);
+
+        // directly access storage object
+        if (empty($this->events$id) && $master_id == $id && ($record = $this->storage->get_object($id))) {
+            $this->events$id = $record = $this->_to_driver_event($record, true);
+        }
+
+        // maybe a recurring instance is requested
+        if (empty($this->events$id) && $master_id != $id) {
+            $instance_id = substr($id, strlen($master_id) + 1);
+
+            if ($record = $this->storage->get_object($master_id)) {
+                $master = $record = $this->_to_driver_event($record);
+            }
+
+            if (!empty($master)) {
+                // check for match in top-level exceptions (aka loose single occurrences)
+                if (!empty($master'_formatobj') && ($instance = $master'_formatobj'->get_instance($instance_id))) {
+                    $this->events$id = $this->_to_driver_event($instance, false, true, $master);
+                }
+                // check for match on the first instance already
+                else if (!empty($master'_instance') && $master'_instance' == $instance_id) {
+                    $this->events$id = $master;
+                }
+                else if (!empty($master'recurrence')) {
+                    $start_date = $master'start';
+                    // For performance reasons we'll get only the specific instance
+                    if (($date = substr($id, strlen($master_id) + 1, 8)) && strlen($date) == 8 && is_numeric($date)) {
+                        $start_date = new DateTime($date . 'T000000', $master'start'->getTimezone());
+                    }
+
+                    $this->get_recurring_events($record, $start_date, null, $id, 1);
+                }
+            }
+        }
+
+        return $this->events$id;
+    }
+
+    /**
+     * Get attachment body
+     * @see calendar_driver::get_attachment_body()
+     */

roundcubemail-1.5.3.tar.gz/plugins/calendar/drivers/caldav/caldav_driver.php Added

@@ -0,0 +1,530 @@
+<?php
+
+/**
+ * CalDAV driver for the Calendar plugin.
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2012-2022, Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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/>.
+ */
+
+require_once(__DIR__ . '/../kolab/kolab_driver.php');
+
+class caldav_driver extends kolab_driver
+{
+    // features this backend supports
+    public $alarms              = true;
+    public $attendees           = true;
+    public $freebusy            = true;
+    public $attachments         = false; // TODO
+    public $undelete            = false; // TODO
+    public $alarm_types         = 'DISPLAY', 'AUDIO';
+    public $categoriesimmutable = true;
+
+    /**
+     * Default constructor
+     */
+    public function __construct($cal)
+    {
+        $cal->require_plugin('libkolab');
+
+        // load helper classes *after* libkolab has been loaded (#3248)
+        require_once(__DIR__ . '/caldav_calendar.php');
+        // require_once(__DIR__ . '/kolab_user_calendar.php');
+        // require_once(__DIR__ . '/caldav_invitation_calendar.php');
+
+        $this->cal = $cal;
+        $this->rc  = $cal->rc;
+
+        // Initialize the CalDAV storage
+        $url = $this->rc->config->get('calendar_caldav_server', 'http://localhost');
+        $this->storage = new kolab_storage_dav($url);
+
+        $this->cal->register_action('push-freebusy', $this, 'push_freebusy');
+        $this->cal->register_action('calendar-acl', $this, 'calendar_acl');
+
+        // $this->freebusy_trigger = $this->rc->config->get('calendar_freebusy_trigger', false);
+
+        // TODO: get configuration for the Bonnie API
+        // $this->bonnie_api = libkolab::get_bonnie_api();
+    }
+
+    /**
+     * Read available calendars from server
+     */
+    protected function _read_calendars()
+    {
+        // already read sources
+        if (isset($this->calendars)) {
+            return $this->calendars;
+        }
+
+        // get all folders that support VEVENT, sorted by namespace/name
+        $folders = $this->storage->get_folders('event');
+            // + $this->storage->get_user_folders('event', true);
+
+        $this->calendars = ;
+
+        foreach ($folders as $folder) {
+            $calendar = $this->_to_calendar($folder);
+            if ($calendar->ready) {
+                $this->calendars$calendar->id = $calendar;
+                if ($calendar->editable) {
+                    $this->has_writeable = true;
+                }
+            }
+        }
+
+        return $this->calendars;
+    }
+
+    /**
+     * Convert kolab_storage_folder into caldav_calendar
+     */
+    protected function _to_calendar($folder)
+    {
+        if ($folder instanceof caldav_calendar) {
+            return $folder;
+        }
+
+        if ($folder instanceof kolab_storage_folder_user) {
+            $calendar = new kolab_user_calendar($folder, $this->cal);
+            $calendar->subscriptions = count($folder->children) > 0;
+        }
+        else {
+            $calendar = new caldav_calendar($folder, $this->cal);
+        }
+
+        return $calendar;
+    }
+
+    /**
+     * Get a list of available calendars from this source.
+     *
+     * @param int    $filter Bitmask defining filter criterias
+     * @param object $tree   Reference to hierarchical folder tree object
+     *
+     * @return array List of calendars
+     */
+    public function list_calendars($filter = 0, &$tree = null)
+    {
+        $this->_read_calendars();
+
+        $folders   = $this->filter_calendars($filter);
+        $calendars = ;
+
+        // include virtual folders for a full folder tree
+/*
+        if (!is_null($tree)) {
+            $folders = $this->storage->folder_hierarchy($folders, $tree);
+        }
+*/
+        $parents = array_keys($this->calendars);
+
+        foreach ($folders as $id => $cal) {
+/*
+            $path = explode('/', $cal->name);
+
+            // find parent
+            do {
+                array_pop($path);
+                $parent_id = $this->storage->folder_id(implode('/', $path));
+            }
+            while (count($path) > 1 && !in_array($parent_id, $parents));
+
+            // restore "real" parent ID
+            if ($parent_id && !in_array($parent_id, $parents)) {
+                $parent_id = $this->storage->folder_id($cal->get_parent());
+            }
+
+            $parents = $cal->id;
+
+            if ($cal->virtual) {
+                $calendars$cal->id = 
+                    'id'       => $cal->id,
+                    'name'     => $cal->get_name(),
+                    'listname' => $cal->get_foldername(),
+                    'editname' => $cal->get_foldername(),
+                    'virtual'  => true,
+                    'editable' => false,
+                    'group'    => $cal->get_namespace(),
+                ;
+            }
+            else {
+*/
+                // additional folders may come from kolab_storage_dav::folder_hierarchy() above
+                // make sure we deal with caldav_calendar instances
+                $cal = $this->_to_calendar($cal);
+                $this->calendars$cal->id = $cal;
+
+                $is_user = ($cal instanceof caldav_user_calendar);
+
+                $calendars$cal->id = 
+                    'id'        => $cal->id,
+                    'name'      => $cal->get_name(),
+                    'listname'  => $cal->get_foldername(),
+                    'editname'  => $cal->get_foldername(),
+                    'title'     => '', // $cal->get_title(),
+                    'color'     => $cal->get_color(),
+                    'editable'  => $cal->editable,
+                    'group'     => $is_user ? 'other user' : $cal->get_namespace(),
+                    'active'    => $cal->is_active(),
+                    'owner'     => $cal->get_owner(),
+                    'removable' => !$cal->default,
+                    // extras to hide some elements in the UI
+                    'subscriptions' => false,
+                    'driver' => 'caldav',
+                ;
+
+                if (!$is_user) {
+                    $calendars$cal->id += 
+                        'default'    => $cal->default,
+                        'rights'     => $cal->rights,
+                        'showalarms' => $cal->alarms,
+                        'history'    => !empty($this->bonnie_api),
+                        'children'   => true,  // TODO: determine if that folder indeed has child folders
+                        'parent'     => $parent_id,

roundcubemail-1.5.3.tar.gz/plugins/calendar/drivers/caldav/caldav_invitation_calendar.php Added

@@ -0,0 +1,47 @@
+<?php
+
+/**
+ * CalDAV calendar storage class simulating a virtual calendar listing pedning/declined invitations
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2014-2022, Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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/>.
+ */
+
+require_once(__DIR__ . '/../kolab/kolab_driver.php');
+require_once(__DIR__ . '/../kolab/kolab_invitation_calendar.php');
+
+class caldav_invitation_calendar extends kolab_invitation_calendar
+{
+    public $id = '__caldav_invitation__';
+
+    /**
+     * Default constructor
+     */
+    public function __construct($id, $calendar)
+    {
+        $this->cal = $calendar;
+        $this->id  = $id;
+    }
+
+    /**
+     * Compose an URL for CalDAV access to this calendar (if configured)
+     */
+    public function get_caldav_url()
+    {
+        return false; // TODO
+    }
+}

roundcubemail-1.5.3.tar.gz/plugins/calendar/drivers/kolab/kolab_driver.php Changed

@@ -37,12 +37,13 @@
     public $alarm_types         = 'DISPLAY', 'AUDIO';
     public $categoriesimmutable = true;
 
-    private $rc;
-    private $cal;
-    private $calendars;
-    private $has_writeable    = false;
-    private $freebusy_trigger = false;
-    private $bonnie_api       = false;
+    protected $rc;
+    protected $cal;
+    protected $calendars;
+    protected $storage;
+    protected $has_writeable    = false;
+    protected $freebusy_trigger = false;
+    protected $bonnie_api       = false;
 
     /**
      * Default constructor
@@ -56,8 +57,9 @@
         require_once(__DIR__ . '/kolab_user_calendar.php');
         require_once(__DIR__ . '/kolab_invitation_calendar.php');
 
-        $this->cal = $cal;
-        $this->rc  = $cal->rc;
+        $this->cal     = $cal;
+        $this->rc      = $cal->rc;
+        $this->storage = new kolab_storage();
 
         $this->cal->register_action('push-freebusy', $this, 'push_freebusy');
         $this->cal->register_action('calendar-acl', $this, 'calendar_acl');
@@ -79,7 +81,7 @@
     /**
      * Read available calendars from server
      */
-    private function _read_calendars()
+    protected function _read_calendars()
     {
         // already read sources
         if (isset($this->calendars)) {
@@ -87,8 +89,8 @@
         }
 
         // get all folders that have "event" type, sorted by namespace/name
-        $folders = kolab_storage::sort_folders(
-            kolab_storage::get_folders('event') + kolab_storage::get_user_folders('event', true)
+        $folders = $this->storage->sort_folders(
+            $this->storage->get_folders('event') + kolab_storage::get_user_folders('event', true)
         );
 
         $this->calendars = ;
@@ -109,7 +111,7 @@
     /**
      * Convert kolab_storage_folder into kolab_calendar
      */
-    private function _to_calendar($folder)
+    protected function _to_calendar($folder)
     {
         if ($folder instanceof kolab_calendar) {
             return $folder;
@@ -152,7 +154,7 @@
 
         // include virtual folders for a full folder tree
         if (!is_null($tree)) {
-            $folders = kolab_storage::folder_hierarchy($folders, $tree);
+            $folders = $this->storage->folder_hierarchy($folders, $tree);
         }
 
         $parents = array_keys($this->calendars);
@@ -163,13 +165,13 @@
             // find parent
             do {
                 array_pop($imap_path);
-                $parent_id = kolab_storage::folder_id(join($delim, $imap_path));
+                $parent_id = $this->storage->folder_id(join($delim, $imap_path));
             }
             while (count($imap_path) > 1 && !in_array($parent_id, $parents));
 
             // restore "real" parent ID
             if ($parent_id && !in_array($parent_id, $parents)) {
-                $parent_id = kolab_storage::folder_id($cal->get_parent());
+                $parent_id = $this->storage->folder_id($cal->get_parent());
             }
 
             $parents = $cal->id;
@@ -385,15 +387,15 @@
         $prop'active'     = true;
         $prop'subscribed' = true;
 
-        $folder = kolab_storage::folder_update($prop);
+        $folder = $this->storage->folder_update($prop);
 
         if ($folder === false) {
-            $this->last_error = $this->cal->gettext(kolab_storage::$last_error);
+            $this->last_error = $this->cal->gettext($this->storage->last_error);
             return false;
         }
 
         // create ID
-        $id = kolab_storage::folder_id($folder);
+        $id = $this->storage->folder_id($folder);
 
         // save color in user prefs (temp. solution)
         $prefs'kolab_calendars' = $this->rc->config->get('kolab_calendars', );
@@ -467,22 +469,22 @@
 
             // apply to child folders, too
             if (!empty($prop'recursive')) {
-                foreach ((array) kolab_storage::list_folders($cal->storage->name, '*', 'event') as $subfolder) {
+                foreach ((array) $this->storage->list_folders($cal->storage->name, '*', 'event') as $subfolder) {
                     if (isset($prop'permanent')) {
                         if ($prop'permanent') {
-                            kolab_storage::folder_subscribe($subfolder);
+                            $this->storage->folder_subscribe($subfolder);
                         }
                         else {
-                            kolab_storage::folder_unsubscribe($subfolder);
+                            $this->storage->folder_unsubscribe($subfolder);
                         }
                     }
 
                     if (isset($prop'active')) {
                         if ($prop'active') {
-                            kolab_storage::folder_activate($subfolder);
+                            $this->storage->folder_activate($subfolder);
                         }
                         else {
-                            kolab_storage::folder_deactivate($subfolder);
+                            $this->storage->folder_deactivate($subfolder);
                         }
                     }
                 }
@@ -511,7 +513,7 @@
             $folder = $cal->get_realname();
 
             // TODO: unsubscribe if no admin rights
-            if (kolab_storage::folder_delete($folder)) {
+            if ($this->storage->folder_delete($folder)) {
                 // remove color in user prefs (temp. solution)
                 $prefs'kolab_calendars' = $this->rc->config->get('kolab_calendars', );
                 unset($prefs'kolab_calendars'$prop'id');
@@ -520,7 +522,7 @@
                 return true;
             }
             else {
-                $this->last_error = kolab_storage::$last_error;
+                $this->last_error = $this->storage->last_error;
             }
         }
 
@@ -537,7 +539,7 @@
      */
     public function search_calendars($query, $source)
     {
-        if (!kolab_storage::setup()) {
+        if (!$this->storage->setup()) {
             return ;
         }
 
@@ -546,7 +548,7 @@
 
         // find unsubscribed IMAP folders that have "event" type
         if ($source == 'folders') {
-            foreach ((array) kolab_storage::search_folders('event', $query, 'other') as $folder) {
+            foreach ((array) $this->storage->search_folders('event', $query, 'other') as $folder) {
                 $calendar = new kolab_calendar($folder->name, $this->cal);
                 $this->calendars$calendar->id = $calendar;
             }
@@ -556,12 +558,12 @@
             // we have slightly more space, so display twice the number
             $limit = $this->rc->config->get('autocomplete_max', 15) * 2;
 
-            foreach (kolab_storage::search_users($query, 0, , $limit, $count) as $user) {
+            foreach ($this->storage->search_users($query, 0, , $limit, $count) as $user) {
                 $calendar = new kolab_user_calendar($user, $this->cal);
                 $this->calendars$calendar->id = $calendar;
 
                 // search for calendar folders shared by this user
-                foreach (kolab_storage::list_user_folders($user, 'event', false) as $foldername) {
+                foreach ($this->storage->list_user_folders($user, 'event', false) as $foldername) {
                     $cal = new kolab_calendar($foldername, $this->cal);
                     $this->calendars$cal->id = $cal;
                     $calendar->subscriptions = true;
@@ -1001,7 +1003,7 @@
     /**
      * Wrapper to update an event object depending on the given savemode
      */
-    private function update_event($event)
+    protected function update_event($event)
     {
         if (!($storage = $this->get_calendar($event'calendar'))) {
             return false;
@@ -1970,7 +1972,7 @@
     /**
      *
      */
-    private function get_recurrence_count($event, $dtstart)
+    protected function get_recurrence_count($event, $dtstart)
     {

roundcubemail-1.5.3.tar.gz/plugins/calendar/lib/calendar_ui.php Changed

@@ -381,15 +381,17 @@
                     );
                 }
 
-                $content .= html::tag('input', 
-                        'type'    => 'checkbox',
-                        'name'    => '_cal',
-                        'value'   => $id,
-                        'checked' => !empty($prop'active'),
-                        'aria-labelledby' => $label_id
-                    )
-                    . html::span('actions', $actions)
-                    . html::span('class' => 'handle', 'style' => "background-color: #$color", '&nbsp;');
+                if (!isset($prop'subscriptions') || $prop'subscriptions' !== false) {
+                    $content .= html::tag('input', 
+                            'type'    => 'checkbox',
+                            'name'    => '_cal',
+                            'value'   => $id,
+                            'checked' => !empty($prop'active'),
+                            'aria-labelledby' => $label_id
+                        )
+                        . html::span('actions', $actions)
+                        . html::span('class' => 'handle', 'style' => "background-color: #$color", '&nbsp;');
+                }
             }
 
             $content = html::div(join(' ', $classes), $content);

roundcubemail-1.5.3.tar.gz/plugins/calendar/skins/elastic/templates/calendar.html Changed

roundcubemail-1.5.3.tar.gz/plugins/kolab_addressbook/config.inc.php Changed

@@ -1,5 +1,10 @@
 <?php
 
+// Backend type (kolab, carddav)
+$config'kolab_addressbook_driver' = "kolab";
+
+// CalDAV server location (required when kolab_addressbook_driver = carddav)
+$config'kolab_addressbook_carddav_server' = "http://localhost";
 
 // This option allows to set addressbooks priority or to disable some
 // of them. Disabled addressbooks will be not shown in the UI. Default: 0.
@@ -15,7 +20,8 @@
 // %u - Current webmail user name
 // %n - Folder name
 // %i - Folder UUID
-// $config'kolab_addressbook_carddav_url' = 'http://%h/iRony/addressbooks/%u/%i';
+// For example: 'http://%h/iRony/addressbooks/%u/%i'
+$config'kolab_addressbook_carddav_url' = null;
 
 // Name of LDAP addressbook (a key in ldap_public configuration array) for which
 // the CardDAV URI will be displayed if kolab_addressbook_carddav_url is set.
@@ -31,5 +37,3 @@
 // ignore these properties and allow modifications which then result in sync errors because the server
 // denies such updates.
 $config'kolab_addressbook_carddav_ldap' = '';
-
-?>

roundcubemail-1.5.3.tar.gz/plugins/kolab_addressbook/config.inc.php.dist Changed

roundcubemail-1.5.3.tar.gz/plugins/kolab_addressbook/kolab_addressbook.php Changed

@@ -31,13 +31,13 @@
 {
     public $task = '?(?!logout).*';
 
+    public $driver;
+    public $bonnie_api = false;
+
     private $sources;
-    private $folders;
     private $rc;
     private $ui;
 
-    public $bonnie_api = false;
-
     const GLOBAL_FIRST = 0;
     const PERSONAL_FIRST = 1;
     const GLOBAL_ONLY = 2;
@@ -48,13 +48,17 @@
      */
     public function init()
     {
-        require_once(dirname(__FILE__) . '/lib/rcube_kolab_contacts.php');
-
         $this->rc = rcube::get_instance();
 
         // load required plugin
         $this->require_plugin('libkolab');
 
+        $this->load_config();
+
+        $this->driver = $this->rc->config->get('kolab_addressbook_driver') ?: 'kolab';
+        $driver_class = 'rcube_' . $this->driver . '_contacts';
+        require_once(dirname(__FILE__) . '/lib/' . $driver_class . '.php');
+
         // register hooks
         $this->add_hook('addressbooks_list', array($this, 'address_sources'));
         $this->add_hook('addressbook_get', array($this, 'get_address_book'));
@@ -81,7 +85,6 @@
 
             // Load UI elements
             if ($this->api->output->type == 'html') {
-                $this->load_config();
                 require_once($this->home . '/lib/kolab_addressbook_ui.php');
                 $this->ui = new kolab_addressbook_ui($this);
 
@@ -103,9 +106,11 @@
             $this->add_hook('preferences_save', array($this, 'prefs_save'));
         }
 
-        $this->add_hook('folder_delete', array($this, 'prefs_folder_delete'));
-        $this->add_hook('folder_rename', array($this, 'prefs_folder_rename'));
-        $this->add_hook('folder_update', array($this, 'prefs_folder_update'));
+        if ($this->driver == 'kolab') {
+            $this->add_hook('folder_delete', array($this, 'prefs_folder_delete'));
+            $this->add_hook('folder_rename', array($this, 'prefs_folder_rename'));
+            $this->add_hook('folder_update', array($this, 'prefs_folder_update'));
+        }
     }
 
     /**
@@ -211,10 +216,23 @@
             $out .= $this->addressbook_list_item($id, $source, $jsdata) . '</li>';
         }
 
+        $filter  = function($source) { return !empty($source'kolab') && empty($source'hidden'); };
+        $folders = array_filter($sources, $filter);
+
         // render a hierarchical list of kolab contact folders
-        kolab_storage::folder_hierarchy($this->folders, $tree);
-        if ($tree && !empty($tree->children)) {
-            $out .= $this->folder_tree_html($tree, $sources, $jsdata);
+        // TODO: Move this to the drivers
+        if ($this->driver == 'kolab') {
+            $folders = kolab_storage::sort_folders(kolab_storage::get_folders('contact'));
+            kolab_storage::folder_hierarchy($folders, $tree);
+            if ($tree && !empty($tree->children)) {
+                $out .= $this->folder_tree_html($tree, $sources, $jsdata);
+            }
+        }
+        else {
+            foreach ($folders as $j => $source) {
+                $id = strval(strlen($source'id') ? $source'id' : $j);
+                $out .= $this->addressbook_list_item($id, $source, $jsdata) . '</li>';
+            }
         }
 
         $this->rc->output->set_env('contactgroups', array_filter($jsdata, function($src){ return $src'type' == 'group'; }));
@@ -302,7 +320,7 @@
                 ), $name)
         );
 
-        if (isset($source'subscribed')) {
+        if ($this->driver == 'kolab' && isset($source'subscribed')) {
             $inner .= html::span(array(
                 'class' => 'subscribed',
                 'title' => $this->gettext('foldersubscribe'),
@@ -395,7 +413,6 @@
         return $args;
     }
 
-
     /**
      * Getter for the rcube_addressbook instance
      *
@@ -406,16 +423,15 @@
     public function get_address_book($p)
     {
         if ($p'id') {
-            $id     = kolab_storage::id_decode($p'id');
-            $folder = kolab_storage::get_folder($id);
-
-            // try with unencoded (old-style) identifier
-            if ((!$folder || $folder->type != 'contact') && $id != $p'id') {
-                $folder = kolab_storage::get_folder($p'id');
+            if ($this->driver == 'carddav') {
+                $source = rcube_carddav_contacts::get_address_book($p'id');
+            }
+            else {
+                $source = rcube_kolab_contacts::get_address_book($p'id');
             }
 
-            if ($folder && $folder->type == 'contact') {
-                $p'instance' = new rcube_kolab_contacts($folder->name);
+            if ($source) {
+                $p'instance' = $source;
 
                 // flag source as writeable if 'i' right is given
                 if ($p'writeable' && $this->rc->action == 'save' && strpos($p'instance'->rights, 'i') !== false) {
@@ -430,57 +446,40 @@
         return $p;
     }
 
-
+    /**
+     * List addressbook sources list
+     */
     private function _list_sources()
     {
         // already read sources
-        if (isset($this->sources))
+        if (isset($this->sources)) {
             return $this->sources;
+        }
 
-        kolab_storage::$encode_ids = true;
-        $this->sources = array();
-        $this->folders = array();
+        $this->sources = ;
 
         $abook_prio = $this->addressbook_prio();
 
         // Personal address source(s) disabled?
-        if ($abook_prio == self::GLOBAL_ONLY) {
+        if ($abook_prio == kolab_addressbook::GLOBAL_ONLY) {
             return $this->sources;
         }
 
-        // get all folders that have "contact" type
-        $folders = kolab_storage::sort_folders(kolab_storage::get_folders('contact'));
-
-        if (PEAR::isError($folders)) {
-            rcube::raise_error(array(
-              'code' => 600, 'type' => 'php',
-              'file' => __FILE__, 'line' => __LINE__,
-              'message' => "Failed to list contact folders from Kolab server:" . $folders->getMessage()),
-            true, false);
+        if ($this->driver == 'carddav') {
+            $folders = rcube_carddav_contacts::list_folders();
         }
         else {
-            // we need at least one folder to prevent from errors in Roundcube core
-            // when there's also no sql nor ldap addressbook (Bug #2086)
-            if (empty($folders)) {
-                if ($folder = kolab_storage::create_default_folder('contact')) {
-                    $folders = array(new kolab_storage_folder($folder, 'contact'));
-                }
-            }
+            $folders = rcube_kolab_contacts::list_folders();
+        }
 
-            // convert to UTF8 and sort
-            foreach ($folders as $folder) {
-                // create instance of rcube_contacts
-                $abook_id = $folder->id;
-                $abook = new rcube_kolab_contacts($folder->name);
-                $this->sources$abook_id = $abook;
-                $this->folders$abook_id = $folder;
-            }
+        // get all folders that have "contact" type
+        foreach ($folders as $id => $source) {
+            $this->sources$id = $source;
         }
 
         return $this->sources;
     }
 
-
     /**
      * Plugin hook called before rendering the contact form or detail view
      *

roundcubemail-1.5.3.tar.gz/plugins/kolab_addressbook/lib/kolab_addressbook_ui.php Changed

@@ -54,6 +54,10 @@
             // Include stylesheet (for directorylist)
             $this->plugin->include_stylesheet($this->plugin->local_skin_path().'/kolab_addressbook.css');
 
+            if ($this->plugin->driver != 'kolab') {
+                return;
+            }
+
             // include kolab folderlist widget if available
             if (in_array('libkolab', $this->plugin->api->loaded_plugins())) {
                 $this->plugin->api->include_script('libkolab/libkolab.js');
@@ -66,20 +70,20 @@
             $idx     = 0;
 
             if ($dav_url = $this->rc->config->get('kolab_addressbook_carddav_url')) {
-              $options = 'book-showurl';
-              $this->rc->output->set_env('kolab_addressbook_carddav_url', true);
-
-              // set CardDAV URI for specified ldap addressbook
-              if ($ldap_abook = $this->rc->config->get('kolab_addressbook_carddav_ldap')) {
-                $dav_ldap_url = strtr($dav_url, array(
-                    '%h' => $_SERVER'HTTP_HOST',
-                    '%u' => urlencode($this->rc->get_user_name()),
-                    '%i' => 'ldap-directory',
-                    '%n' => '',
-                ));
-                $this->rc->output->set_env('kolab_addressbook_carddav_ldap', $ldap_abook);
-                $this->rc->output->set_env('kolab_addressbook_carddav_ldap_url', $dav_ldap_url);
-              }
+                $options = 'book-showurl';
+                $this->rc->output->set_env('kolab_addressbook_carddav_url', true);
+
+                // set CardDAV URI for specified ldap addressbook
+                if ($ldap_abook = $this->rc->config->get('kolab_addressbook_carddav_ldap')) {
+                    $dav_ldap_url = strtr($dav_url, array(
+                        '%h' => $_SERVER'HTTP_HOST',
+                        '%u' => urlencode($this->rc->get_user_name()),
+                        '%i' => 'ldap-directory',
+                        '%n' => '',
+                    ));
+                    $this->rc->output->set_env('kolab_addressbook_carddav_ldap', $ldap_abook);
+                    $this->rc->output->set_env('kolab_addressbook_carddav_ldap_url', $dav_ldap_url);
+                }
             }
 
             foreach ($options as $command) {

roundcubemail-1.5.3.tar.gz/plugins/kolab_addressbook/lib/rcube_carddav_contacts.php Added

@@ -0,0 +1,1285 @@
+<?php
+
+/**
+ * Backend class for a custom address book using CardDAV service.
+ *
+ * This part of the Roundcube+Kolab integration and connects the
+ * rcube_addressbook interface with the kolab_storage_dav wrapper from libkolab
+ *
+ * @author Thomas Bruederli <bruederli@kolabsys.com>
+ * @author Aleksander Machniak <machniak@apheleia-it.chm>
+ *
+ * Copyright (C) 2011-2022, Kolab Systems AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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/>.
+ *
+ * @see rcube_addressbook
+ */
+class rcube_carddav_contacts extends rcube_addressbook
+{
+    public $primary_key = 'ID';
+    public $rights   = 'lrs';
+    public $readonly = true;
+    public $undelete = false;
+    public $groups = false; // TODO
+
+    public $coltypes = 
+        'name'         => 'limit' => 1,
+        'firstname'    => 'limit' => 1,
+        'surname'      => 'limit' => 1,
+        'middlename'   => 'limit' => 1,
+        'prefix'       => 'limit' => 1,
+        'suffix'       => 'limit' => 1,
+        'nickname'     => 'limit' => 1,
+        'jobtitle'     => 'limit' => 1,
+        'organization' => 'limit' => 1,
+        'department'   => 'limit' => 1,
+        'email'        => 'subtypes' => 'home','work','other',
+        'phone'        => ,
+        'address'      => 'subtypes' => 'home','work','office',
+        'website'      => 'subtypes' => 'homepage','blog',
+        'im'           => 'subtypes' => null,
+        'gender'       => 'limit' => 1,
+        'birthday'     => 'limit' => 1,
+        'anniversary'  => 'limit' => 1,
+        'manager'      => 'limit' => null,
+        'assistant'    => 'limit' => null,
+        'spouse'       => 'limit' => 1,
+        'notes'        => 'limit' => 1,
+        'photo'        => 'limit' => 1,
+    ;
+
+    public $vcard_map = 
+    //    'profession'     => 'X-PROFESSION',
+    //    'officelocation' => 'X-OFFICE-LOCATION',
+    //    'initials'       => 'X-INITIALS',
+    //    'children'       => 'X-CHILDREN',
+    //    'freebusyurl'    => 'X-FREEBUSY-URL',
+    //    'pgppublickey'   => 'KEY',
+        'uid'            => 'UID',
+    ;
+
+    /**
+     * List of date type fields
+     */
+    public $date_cols = 'birthday', 'anniversary';
+
+    public $fulltext_cols  = 'name', 'firstname', 'surname', 'middlename', 'email';
+
+    private $gid;
+    private $storage;
+    private $dataset;
+    private $sortindex;
+    private $contacts;
+    private $distlists;
+    private $groupmembers;
+    private $filter;
+    private $result;
+    private $namespace;
+    private $action;
+
+    // list of fields used for searching in "All fields" mode
+    private $search_fields = 
+        'name',
+        'firstname',
+        'surname',
+        'middlename',
+        'prefix',
+        'suffix',
+        'nickname',
+        'jobtitle',
+        'organization',
+        'department',
+        'email',
+        'phone',
+        'address',
+//        'profession',
+        'manager',
+        'assistant',
+        'spouse',
+        'children',
+        'notes',
+    ;
+
+
+    /**
+     * Object constructor
+     */
+    public function __construct($dav_folder = null)
+    {
+        $this->storage = $dav_folder;
+        $this->ready   = !empty($this->storage);
+
+        // Set readonly and rights flags according to folder permissions
+        if ($this->ready) {
+            if ($this->storage->get_owner() == $_SESSION'username') {
+                $this->readonly = false;
+                $this->rights = 'lrswikxtea';
+            }
+            else {
+                $rights = $this->storage->get_myrights();
+                if ($rights && !PEAR::isError($rights)) {
+                    $this->rights = $rights;
+                    if (strpos($rights, 'i') !== false && strpos($rights, 't') !== false) {
+                        $this->readonly = false;
+                    }
+                }
+            }
+        }
+
+        $this->action = rcube::get_instance()->action;
+    }
+
+    /**
+     * Getter for the address book name to be displayed
+     *
+     * @return string Name of this address book
+     */
+    public function get_name()
+    {
+        return $this->storage->get_name();
+    }
+
+    /**
+     * Wrapper for kolab_storage_folder::get_foldername()
+     */
+    public function get_foldername()
+    {
+        return $this->storage->get_foldername();
+    }
+
+    /**
+     * Getter for the folder name
+     *
+     * @return string Name of the folder
+     */
+    public function get_realname()
+    {
+        return $this->get_name();
+    }
+
+    /**
+     * Getter for the name of the namespace to which the IMAP folder belongs
+     *
+     * @return string Name of the namespace (personal, other, shared)
+     */
+    public function get_namespace()
+    {
+        if ($this->namespace === null && $this->ready) {
+            $this->namespace = $this->storage->get_namespace();
+        }
+
+        return $this->namespace;
+    }
+
+    /**
+     * Getter for parent folder path
+     *
+     * @return string Full path to parent folder
+     */
+    public function get_parent()
+    {
+        return $this->storage->get_parent();
+    }
+
+    /**
+     * Check subscription status of this folder
+     *
+     * @return boolean True if subscribed, false if not

roundcubemail-1.5.3.tar.gz/plugins/kolab_addressbook/lib/rcube_kolab_contacts.php Changed

@@ -313,6 +313,64 @@
     }
 
     /**
+     * List addressbook sources (folders)
+     */
+    public static function list_folders()
+    {
+        kolab_storage::$encode_ids = true;
+
+        // get all folders that have "contact" type
+        $folders = kolab_storage::sort_folders(kolab_storage::get_folders('contact'));
+
+        if (PEAR::isError($folders)) {
+            rcube::raise_error(
+                    'code' => 600, 'file' => __FILE__, 'line' => __LINE__,
+                    'message' => "Failed to list contact folders from Kolab server:" . $folders->getMessage()
+                ,
+                true, false);
+
+            return ;
+        }
+
+        // we need at least one folder to prevent from errors in Roundcube core
+        // when there's also no sql nor ldap addressbook (Bug #2086)
+        if (empty($folders)) {
+            if ($folder = kolab_storage::create_default_folder('contact')) {
+                $folders = new kolab_storage_folder($folder, 'contact');
+            }
+        }
+
+        $sources = ;
+        foreach ($folders as $folder) {
+            $sources$folder->id = new rcube_kolab_contacts($folder->name);
+        }
+
+        return $sources;
+    }
+
+    /**
+     * Getter for the rcube_addressbook instance
+     *
+     * @param string $id Addressbook (folder) ID
+     *
+     * @return ?rcube_kolab_contacts
+     */
+    public static function get_address_book($id)
+    {
+        $folderId = kolab_storage::id_decode($id);
+        $folder   = kolab_storage::get_folder($folderId);
+
+        // try with unencoded (old-style) identifier
+        if ((!$folder || $folder->type != 'contact') && $folderId != $id) {
+            $folder = kolab_storage::get_folder($id);
+        }
+
+        if ($folder && $folder->type == 'contact') {
+            return new rcube_kolab_contacts($folder->name);
+        }
+    }
+
+    /**
      * List all active contact groups of this source
      *
      * @param string Optional search string to match group name

roundcubemail-1.5.3.tar.gz/plugins/libcalendaring/libvcalendar.php Changed

roundcubemail-1.5.3.tar.gz/plugins/libkolab/SQL/mysql.initial.sql Changed

@@ -1,10 +1,3 @@
-/**
- * libkolab database schema
- *
- * @author Thomas Bruederli
- * @licence GNU AGPL
- */
-
 SET FOREIGN_KEY_CHECKS=0;
 
 DROP TABLE IF EXISTS `kolab_folders`;
@@ -177,6 +170,46 @@
   INDEX `freebusy_uid2msguid` (`folder_id`,`uid`,`msguid`)
 ) ROW_FORMAT=DYNAMIC ENGINE=INNODB CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
 
+DROP TABLE IF EXISTS `kolab_cache_dav_contact`;
+
+CREATE TABLE `kolab_cache_dav_contact` (
+  `folder_id` BIGINT UNSIGNED NOT NULL,
+  `uid` VARCHAR(512) NOT NULL,
+  `etag` VARCHAR(128) DEFAULT NULL,
+  `created` DATETIME DEFAULT NULL,
+  `changed` DATETIME DEFAULT NULL,
+  `data` LONGTEXT NOT NULL,
+  `tags` TEXT NOT NULL,
+  `words` TEXT NOT NULL,
+  `type` VARCHAR(32) CHARACTER SET ascii NOT NULL,
+  `name` VARCHAR(255) NOT NULL,
+  `firstname` VARCHAR(255) NOT NULL,
+  `surname` VARCHAR(255) NOT NULL,
+  `email` VARCHAR(255) NOT NULL,
+  CONSTRAINT `fk_kolab_cache_dav_contact_folder` FOREIGN KEY (`folder_id`)
+    REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
+  PRIMARY KEY(`folder_id`,`uid`),
+  INDEX `contact_type` (`folder_id`,`type`)
+) ROW_FORMAT=DYNAMIC ENGINE=INNODB CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+DROP TABLE IF EXISTS `kolab_cache_dav_event`;
+
+CREATE TABLE `kolab_cache_dav_event` (
+  `folder_id` BIGINT UNSIGNED NOT NULL,
+  `uid` VARCHAR(512) NOT NULL,
+  `etag` VARCHAR(128) DEFAULT NULL,
+  `created` DATETIME DEFAULT NULL,
+  `changed` DATETIME DEFAULT NULL,
+  `data` LONGTEXT NOT NULL,
+  `tags` TEXT NOT NULL,
+  `words` TEXT NOT NULL,
+  `dtstart` DATETIME,
+  `dtend` DATETIME,
+  CONSTRAINT `fk_kolab_cache_dav_event_folder` FOREIGN KEY (`folder_id`)
+    REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
+  PRIMARY KEY(`folder_id`,`uid`)
+) ROW_FORMAT=DYNAMIC ENGINE=INNODB CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
 SET FOREIGN_KEY_CHECKS=1;
 
-REPLACE INTO `system` (`name`, `value`) VALUES ('libkolab-version', '2021101100');
+REPLACE INTO `system` (`name`, `value`) VALUES ('libkolab-version', '2022100500');

roundcubemail-1.5.3.tar.gz/plugins/libkolab/SQL/mysql/2022100500.sql Added

@@ -0,0 +1,39 @@
+DROP TABLE IF EXISTS `kolab_cache_dav_contact`;
+
+CREATE TABLE `kolab_cache_dav_contact` (
+  `folder_id` BIGINT UNSIGNED NOT NULL,
+  `uid` VARCHAR(512) NOT NULL,
+  `etag` VARCHAR(128) DEFAULT NULL,
+  `created` DATETIME DEFAULT NULL,
+  `changed` DATETIME DEFAULT NULL,
+  `data` LONGTEXT NOT NULL,
+  `tags` TEXT NOT NULL,
+  `words` TEXT NOT NULL,
+  `type` VARCHAR(32) CHARACTER SET ascii NOT NULL,
+  `name` VARCHAR(255) NOT NULL,
+  `firstname` VARCHAR(255) NOT NULL,
+  `surname` VARCHAR(255) NOT NULL,
+  `email` VARCHAR(255) NOT NULL,
+  CONSTRAINT `fk_kolab_cache_dav_contact_folder` FOREIGN KEY (`folder_id`)
+    REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
+  PRIMARY KEY(`folder_id`,`uid`),
+  INDEX `contact_type` (`folder_id`,`type`)
+) ROW_FORMAT=DYNAMIC ENGINE=INNODB CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+DROP TABLE IF EXISTS `kolab_cache_dav_event`;
+
+CREATE TABLE `kolab_cache_dav_event` (
+  `folder_id` BIGINT UNSIGNED NOT NULL,
+  `uid` VARCHAR(512) NOT NULL,
+  `etag` VARCHAR(128) DEFAULT NULL,
+  `created` DATETIME DEFAULT NULL,
+  `changed` DATETIME DEFAULT NULL,
+  `data` LONGTEXT NOT NULL,
+  `tags` TEXT NOT NULL,
+  `words` TEXT NOT NULL,
+  `dtstart` DATETIME,
+  `dtend` DATETIME,
+  CONSTRAINT `fk_kolab_cache_dav_event_folder` FOREIGN KEY (`folder_id`)
+    REFERENCES `kolab_folders`(`folder_id`) ON DELETE CASCADE ON UPDATE CASCADE,
+  PRIMARY KEY(`folder_id`,`uid`)
+) ROW_FORMAT=DYNAMIC ENGINE=INNODB CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

roundcubemail-1.5.3.tar.gz/plugins/libkolab/SQL/oracle.initial.sql Changed

roundcubemail-1.5.3.tar.gz/plugins/libkolab/SQL/sqlite.initial.sql Changed

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_dav_client.php Added

@@ -0,0 +1,571 @@
+<?php
+
+/**
+ * A *DAV client.
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2022, Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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 kolab_dav_client
+{
+    public $url;
+
+    protected $user;
+    protected $password;
+    protected $rc;
+    protected $responseHeaders = ;
+
+    /**
+     * Object constructor
+     */
+    public function __construct($url)
+    {
+        $this->rc = rcube::get_instance();
+
+        $parsedUrl = parse_url($url);
+
+        if (!empty($parsedUrl'user') && !empty($parsedUrl'pass')) {
+            $this->user     = rawurldecode($parsedUrl'user');
+            $this->password = rawurldecode($parsedUrl'pass');
+
+            $url = str_replace(rawurlencode($this->user) . ':' . rawurlencode($this->password) . '@', '', $url);
+        }
+        else {
+            $this->user     = $this->rc->user->get_username();
+            $this->password = $this->rc->decrypt($_SESSION'password');
+        }
+
+        $this->url = $url;
+    }
+
+    /**
+     * Execute HTTP request to a DAV server
+     */
+    protected function request($path, $method, $body = '', $headers = )
+    {
+        $rcube = rcube::get_instance();
+        $debug = (array) $rcube->config->get('dav_debug');
+
+        $request_config = 
+            'store_body'       => true,
+            'follow_redirects' => true,
+        ;
+
+        $this->responseHeaders = ;
+
+        if ($path && ($rootPath = parse_url($this->url, PHP_URL_PATH)) && strpos($path, $rootPath) === 0) {
+            $path = substr($path, strlen($rootPath));
+        }
+
+        try {
+            $request = $this->initRequest($this->url . $path, $method, $request_config);
+
+            $request->setAuth($this->user, $this->password);
+
+            if ($body) {
+                $request->setBody($body);
+                $request->setHeader('Content-Type' => 'application/xml; charset=utf-8');
+            }
+
+            if (!empty($headers)) {
+                $request->setHeader($headers);
+            }
+
+            if ($debug) {
+                rcube::write_log('dav', "C: {$method}: " . (string) $request->getUrl()
+                     . "\n" . $this->debugBody($body, $request->getHeaders()));
+            }
+
+            $response = $request->send();
+
+            $body = $response->getBody();
+            $code = $response->getStatus();
+
+            if ($debug) {
+                rcube::write_log('dav', "S: {$code}\n" . $this->debugBody($body, $response->getHeader()));
+            }
+
+            if ($code >= 300) {
+                throw new Exception("DAV Error ($code):\n{$body}");
+            }
+
+            $this->responseHeaders = $response->getHeader();
+
+            return $this->parseXML($body);
+        }
+        catch (Exception $e) {
+            rcube::raise_error($e, true, false);
+            return false;
+        }
+    }
+
+    /**
+     * Discover DAV folders of specified type on the server
+     */
+    public function discover($component = 'VEVENT')
+    {
+        $roots = 
+            'VEVENT' => 'calendars',
+            'VTODO' => 'calendars',
+            'VCARD' => 'addressbooks',
+        ;
+
+        $path = parse_url($this->url, PHP_URL_PATH);
+
+        $body = '<?xml version="1.0" encoding="utf-8"?>'
+            . '<d:propfind xmlns:d="DAV:">'
+                . '<d:prop>'
+                    . '<d:current-user-principal />'
+                . '</d:prop>'
+            . '</d:propfind>';
+
+        // Note: Cyrus CardDAV service requires Depth:1 (CalDAV works without it)
+        $response = $this->request('/' . $roots$component, 'PROPFIND', $body, 'Depth' => 1, 'Prefer' => 'return-minimal');
+
+        $elements = $response->getElementsByTagName('response');
+
+        foreach ($elements as $element) {
+            foreach ($element->getElementsByTagName('prop') as $prop) {
+                $principal_href = $prop->nodeValue;
+                break;
+            }
+        }
+
+        if ($path && strpos($principal_href, $path) === 0) {
+            $principal_href = substr($principal_href, strlen($path));
+        }
+
+        $homes = 
+            'VEVENT' => 'calendar-home-set',
+            'VTODO' => 'calendar-home-set',
+            'VCARD' => 'addressbook-home-set',
+        ;
+
+        $ns = 
+            'VEVENT' => 'caldav',
+            'VTODO' => 'caldav',
+            'VCARD' => 'carddav',
+        ;
+
+        $body = '<?xml version="1.0" encoding="utf-8"?>'
+            . '<d:propfind xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:' . $ns$component . '">'
+                . '<d:prop>'
+                    . '<c:' . $homes$component . ' />'
+                . '</d:prop>'
+            . '</d:propfind>';
+
+        $response = $this->request($principal_href, 'PROPFIND', $body);
+
+        $elements = $response->getElementsByTagName('response');
+
+        foreach ($elements as $element) {
+            foreach ($element->getElementsByTagName('prop') as $prop) {
+                $root_href = $prop->nodeValue;
+                break;
+            }
+        }
+
+        if (!empty($root_href)) {
+            if ($path && strpos($root_href, $path) === 0) {
+                $root_href = substr($root_href, strlen($path));
+            }
+        }
+        else {
+            // Kolab iRony's calendar root
+            $root_href = '/' . $roots$component . '/' . rawurlencode($this->user);
+        }
+
+        if ($component == 'VCARD') {
+            $add_ns = '';
+            $add_props = '';
+        }
+        else {
+            $add_ns = ' xmlns:c="urn:ietf:params:xml:ns:caldav" xmlns:a="http://apple.com/ns/ical/"';
+            $add_props = '<c:supported-calendar-component-set /><a:calendar-color />';

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_cache.php Changed

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_dataset.php Changed

@@ -79,18 +79,16 @@
 
     public function offsetSet($offset, $value)
     {
-        $uid = $value'_msguid';
+        $uid = !empty($value'_msguid') ? $value'_msguid' : $value'uid';
 
         if (is_null($offset)) {
             $offset = count($this->index);
-            $this->index = $uid;
-        }
-        else {
-            $this->index$offset = $uid;
         }
 
+        $this->index$offset = $uid;
+
         // keep full payload data in memory if possible
-        if ($this->memlimit && $this->buffer && isset($value'_mailbox')) {
+        if ($this->memlimit && $this->buffer) {
             $this->data$offset = $value;
 
             // check memory usage and stop buffering
@@ -115,8 +113,9 @@
         if (isset($this->data$offset)) {
             return $this->data$offset;
         }
-        else if ($msguid = $this->index$offset) {
-            return $this->cache->get($msguid);
+
+        if ($uid = $this->index$offset) {
+            return $this->cache->get($uid);
         }
 
         return null;

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_dav.php Added

@@ -0,0 +1,492 @@
+<?php
+
+/**
+ * Kolab storage class providing access to groupware objects on a *DAV server.
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2022, Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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 kolab_storage_dav
+{
+    const ERROR_DAV_CONN       = 1;
+    const ERROR_CACHE_DB       = 2;
+    const ERROR_NO_PERMISSION  = 3;
+    const ERROR_INVALID_FOLDER = 4;
+
+    protected $dav;
+    protected $url;
+
+
+    /**
+     * Object constructor
+     */
+    public function __construct($url)
+    {
+        $this->url = $url;
+        $this->setup();
+    }
+
+    /**
+     * Setup the environment
+     */
+    public function setup()
+    {
+        $rcmail = rcube::get_instance();
+
+        $this->config = $rcmail->config;
+        $this->dav = new kolab_dav_client($this->url);
+    }
+
+    /**
+     * Get a list of storage folders for the given data type
+     *
+     * @param string Data type to list folders for (contact,distribution-list,event,task,note)
+     *
+     * @return array List of kolab_storage_dav_folder objects
+     */
+    public function get_folders($type)
+    {
+        $davTypes = 
+            'event' => 'VEVENT',
+            'task'  => 'VTODO',
+            'contact' => 'VCARD',
+        ;
+
+        // TODO: This should be cached
+        $folders = $this->dav->discover($davTypes$type);
+
+        if (is_array($folders)) {
+            foreach ($folders as $idx => $folder) {
+                // Exclude some special folders
+                if (in_array('schedule-inbox', $folder'resource_type') || in_array('schedule-outbox', $folder'resource_type')) {
+                    unset($folders$idx);
+                    continue;
+                }
+
+                $folders$idx = new kolab_storage_dav_folder($this->dav, $folder, $type);
+            }
+        }
+
+        return $folders ?: ;
+    }
+
+    /**
+     * Getter for the storage folder for the given type
+     *
+     * @param string Data type to list folders for (contact,distribution-list,event,task,note)
+     *
+     * @return object kolab_storage_dav_folder The folder object
+     */
+    public function get_default_folder($type)
+    {
+        // TODO: Not used
+    }
+
+    /**
+     * Getter for a specific storage folder
+     *
+     * @param string $id   Folder to access
+     * @param string $type Expected folder type
+     *
+     * @return ?object kolab_storage_folder The folder object
+     */
+    public function get_folder($id, $type = null)
+    {
+        foreach ($this->get_folders($type) as $folder) {
+            if ($folder->id == $id) {
+                return $folder;
+            }
+        }
+    }
+
+    /**
+     * Getter for a single Kolab object, identified by its UID.
+     * This will search all folders storing objects of the given type.
+     *
+     * @param string Object UID
+     * @param string Object type (contact,event,task,journal,file,note,configuration)
+     *
+     * @return array The Kolab object represented as hash array or false if not found
+     */
+    public function get_object($uid, $type)
+    {
+        // TODO
+        return false;
+    }
+
+    /**
+     * Execute cross-folder searches with the given query.
+     *
+     * @param array  Pseudo-SQL query as list of filter parameter triplets
+     * @param string Folder type (contact,event,task,journal,file,note,configuration)
+     * @param int    Expected number of records or limit (for performance reasons)
+     *
+     * @return array List of Kolab data objects (each represented as hash array)
+     */
+    public function select($query, $type, $limit = null)
+    {
+        $result = ;
+
+        foreach ($this->get_folders($type) as $folder) {
+            if ($limit) {
+                $folder->set_order_and_limit(null, $limit);
+            }
+
+            foreach ($folder->select($query) as $object) {
+                $result = $object;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Compose an URL to query the free/busy status for the given user
+     *
+     * @param string Email address of the user to get free/busy data for
+     * @param object DateTime Start of the query range (optional)
+     * @param object DateTime End of the query range (optional)
+     *
+     * @return string Fully qualified URL to query free/busy data
+     */
+    public static function get_freebusy_url($email, $start = null, $end = null)
+    {
+        return kolab_storage::get_freebusy_url($email, $start, $end);
+    }
+
+    /**
+     * Deletes a folder
+     *
+     * @param string $name Folder name
+     *
+     * @return bool True on success, false on failure
+     */
+    public function folder_delete($name)
+    {
+        // TODO
+    }
+
+    /**
+     * Creates a folder
+     *
+     * @param string $name       Folder name (UTF7-IMAP)
+     * @param string $type       Folder type
+     * @param bool   $subscribed Sets folder subscription
+     * @param bool   $active     Sets folder state (client-side subscription)
+     *
+     * @return bool True on success, false on failure
+     */
+    public function folder_create($name, $type = null, $subscribed = false, $active = false)
+    {
+        // TODO
+    }
+
+    /**

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_dav_cache.php Added

@@ -0,0 +1,622 @@
+<?php
+
+/**
+ * Kolab storage cache class providing a local caching layer for Kolab groupware objects.
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2012-2022, Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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 kolab_storage_dav_cache extends kolab_storage_cache
+{
+    /**
+     * Factory constructor
+     */
+    public static function factory(kolab_storage_folder $storage_folder)
+    {
+        $subclass = 'kolab_storage_dav_cache_' . $storage_folder->type;
+        if (class_exists($subclass)) {
+            return new $subclass($storage_folder);
+        }
+
+        rcube::raise_error(
+            'code' => 900, 'message' => "No {$subclass} class found for folder '{$storage_folder->name}'",
+            true
+        );
+
+        return new kolab_storage_dav_cache($storage_folder);
+    }
+
+    /**
+     * Connect cache with a storage folder
+     *
+     * @param kolab_storage_folder The storage folder instance to connect with
+     */
+    public function set_folder(kolab_storage_folder $storage_folder)
+    {
+        $this->folder = $storage_folder;
+
+        if (!$this->folder->valid) {
+            $this->ready = false;
+            return;
+        }
+
+        // compose fully qualified ressource uri for this instance
+        $this->resource_uri = $this->folder->get_resource_uri();
+        $this->cache_table = $this->db->table_name('kolab_cache_dav_' . $this->folder->type);
+        $this->ready = true;
+    }
+
+    /**
+     * Synchronize local cache data with remote
+     */
+    public function synchronize()
+    {
+        // only sync once per request cycle
+        if ($this->synched) {
+            return;
+        }
+
+        $this->sync_start = time();
+
+        // read cached folder metadata
+        $this->_read_folder_data();
+
+        $ctag = $this->folder->get_ctag();
+
+        // check cache status ($this->metadata is set in _read_folder_data())
+        if (
+            empty($this->metadata'ctag')
+            || empty($this->metadata'changed')
+            || $this->metadata'ctag' !== $ctag
+        ) {
+            // lock synchronization for this folder and wait if already locked
+            $this->_sync_lock();
+
+            $result = $this->synchronize_worker();
+
+            // update ctag value (will be written to database in _sync_unlock())
+            if ($result) {
+                $this->metadata'ctag'    = $ctag;
+                $this->metadata'changed' = date(self::DB_DATE_FORMAT, time());
+            }
+
+            // remove lock
+            $this->_sync_unlock();
+        }
+
+        $this->synched = time();
+    }
+
+    /**
+     * Perform cache synchronization
+     */
+    protected function synchronize_worker()
+    {
+        // get effective time limit we have for synchronization (~70% of the execution time)
+        $time_limit = $this->_max_sync_lock_time() * 0.7;
+
+        if (time() - $this->sync_start > $time_limit) {
+            return false;
+        }
+
+        // TODO: Implement synchronization with use of WebDAV-Sync (RFC 6578)
+
+        // Get the objects from the DAV server
+        $dav_index = $this->folder->dav->getIndex($this->folder->href, $this->folder->get_dav_type());
+
+        if (!is_array($dav_index)) {
+            rcube::raise_error(
+                    'code' => 900,
+                    'message' => "Failed to sync the kolab cache for {$this->folder->href}"
+                , true);
+            return false;
+        }
+
+        // WARNING: For now we assume object's href is <calendar-href>/<uid>.ics,
+        //          which would mean there are no duplicates (objects with the same uid).
+        //          With DAV protocol we can't get UID without fetching the whole object.
+        //          Also the folder_id + uid is a unique index in the database.
+        //          In the future we maybe should store the href in database.
+
+        // Determine objects to fetch or delete
+        $new_index    = ;
+        $update_index = ;
+        $old_index    = $this->folder_index(); // uid -> etag
+        $chunk_size   = 20; // max numer of objects per DAV request
+
+        foreach ($dav_index as $object) {
+            $uid = $object'uid';
+            if (isset($old_index$uid)) {
+                $old_etag = $old_index$uid;
+                $old_index$uid = null;
+
+                if ($old_etag === $object'etag') {
+                    // the object didn't change
+                    continue;
+                }
+
+                $update_index$uid = $object'href';
+            }
+            else {
+                $new_index$uid = $object'href';
+            }
+        }
+
+        // Fetch new objects and store in DB
+        if (!empty($new_index)) {
+            foreach (array_chunk($new_index, $chunk_size, true) as $chunk) {
+                $objects = $this->folder->dav->getData($this->folder->href, $this->folder->get_dav_type(), $chunk);
+
+                if (!is_array($objects)) {
+                    rcube::raise_error(
+                            'code' => 900,
+                            'message' => "Failed to sync the kolab cache for {$this->folder->href}"
+                        , true);
+                    return false;
+                }
+
+                foreach ($objects as $object) {
+                    if ($object = $this->folder->from_dav($object)) {
+                        $this->_extended_insert(false, $object);
+                    }
+                }
+
+                $this->_extended_insert(true, null);
+
+                // check time limit and abort sync if running too long
+                if (++$i % 25 == 0 && time() - $this->sync_start > $time_limit) {
+                    return false;
+                }
+            }
+        }
+
+        // Fetch updated objects and store in DB
+        if (!empty($update_index)) {
+            foreach (array_chunk($update_index, $chunk_size, true) as $chunk) {
+                $objects = $this->folder->dav->getData($this->folder->href, $this->folder->get_dav_type(), $chunk);
+
+                if (!is_array($objects)) {
+                    rcube::raise_error(
+                            'code' => 900,
+                            'message' => "Failed to sync the kolab cache for {$this->folder->href}"
+                        , true);
+                    return false;
+                }

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_dav_cache_contact.php Added

@@ -0,0 +1,113 @@
+<?php
+
+/**
+ * Kolab storage cache class for contact objects
+ *
+ * @author Aleksander Machniak <machniak@apcheleia-it.ch>
+ *
+ * Copyright (C) 2013-2022, Apheleia IT AG <contact@apcheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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 kolab_storage_dav_cache_contact extends kolab_storage_dav_cache
+{
+    protected $extra_cols_max = 255;
+    protected $extra_cols     = 'type', 'name', 'firstname', 'surname', 'email';
+    protected $data_props     = 'type', 'name', 'firstname', 'middlename', 'prefix', 'suffix', 'surname', 'email', 'organization', 'member';
+    protected $fulltext_cols  = 'name', 'firstname', 'surname', 'middlename', 'email';
+
+    /**
+     * Helper method to convert the given Kolab object into a dataset to be written to cache
+     *
+     * @override
+     */
+    protected function _serialize($object)
+    {
+        $sql_data = parent::_serialize($object);
+        $sql_data'type' = $object'_type' ?: 'contact';
+
+        // columns for sorting
+        $sql_data'name'      = rcube_charset::clean($object'name' . $object'prefix');
+        $sql_data'firstname' = rcube_charset::clean($object'firstname' . $object'middlename' . $object'surname');
+        $sql_data'surname'   = rcube_charset::clean($object'surname'   . $object'firstname'  . $object'middlename');
+        $sql_data'email'     = '';
+
+        foreach ($object as $colname => $value) {
+            list($col, $field) = explode(':', $colname);
+            if ($col == 'email' && !empty($value)) {
+                $sql_data'email' = is_array($value) ? $value0 : $value;
+                break;
+            }
+        }
+
+        // use organization if name is empty
+        if (empty($sql_data'name') && !empty($object'organization')) {
+            $sql_data'name' = rcube_charset::clean($object'organization');
+        }
+
+        // make sure some data is not longer that database limit (#5291)
+        foreach ($this->extra_cols as $col) {
+            if (strlen($sql_data$col) > $this->extra_cols_max) {
+                $sql_data$col = rcube_charset::clean(substr($sql_data$col, 0,  $this->extra_cols_max));
+            }
+        }
+
+        $sql_data'tags'  = ' ' . join(' ', $this->get_tags($object)) . ' ';  // pad with spaces for strict/prefix search
+        $sql_data'words' = ' ' . join(' ', $this->get_words($object)) . ' ';
+
+        return $sql_data;
+    }
+
+    /**
+     * Callback to get words to index for fulltext search
+     *
+     * @return array List of words to save in cache
+     */
+    public function get_words($object)
+    {
+        $data = '';
+
+        foreach ($object as $colname => $value) {
+            list($col, $field) = explode(':', $colname);
+
+            $val = '';
+            if (in_array($col, $this->fulltext_cols)) {
+                $val = is_array($value) ? join(' ', $value) : $value;
+            }
+
+            if (strlen($val)) {
+                $data .= $val . ' ';
+            }
+        }
+
+        return array_unique(rcube_utils::normalize_string($data, true));
+    }
+
+    /**
+     * Callback to get object specific tags to cache
+     *
+     * @return array List of tags to save in cache
+     */
+    public function get_tags($object)
+    {
+        $tags = ;
+
+        if (!empty($object'birthday')) {
+            $tags = 'x-has-birthday';
+        }
+
+        return $tags;
+    }
+}

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_dav_cache_event.php Added

@@ -0,0 +1,152 @@
+<?php
+
+/**
+ * Kolab storage cache class for calendar event objects
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2013-2022 Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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 kolab_storage_dav_cache_event extends kolab_storage_dav_cache
+{
+    protected $extra_cols = 'dtstart','dtend';
+    protected $data_props = 'categories', 'status', 'attendees';
+    protected $fulltext_cols = 'title', 'description', 'location', 'attendees:name', 'attendees:email', 'categories';
+
+    /**
+     * Helper method to convert the given Kolab object into a dataset to be written to cache
+     *
+     * @override
+     */
+    protected function _serialize($object)
+    {
+        $sql_data = parent::_serialize($object);
+
+        $sql_data'dtstart' = $this->_convert_datetime($object'start');
+        $sql_data'dtend'   = $this->_convert_datetime($object'end');
+
+        // extend date range for recurring events
+        if (!empty($object'recurrence')) {
+            if (empty($object'_formatobj')) {
+                $event_xml = new kolab_format_event();
+                $event_xml->set($object);
+                $object'_formatobj' = $event_xml;
+            }
+
+            $recurrence = new kolab_date_recurrence($object'_formatobj');
+            $dtend = $recurrence->end() ?: new DateTime('now +100 years');
+            $sql_data'dtend' = $this->_convert_datetime($dtend);
+        }
+
+        // extend start/end dates to spawn all exceptions
+        if (is_array($object'exceptions')) {
+            foreach ($object'exceptions' as $exception) {
+                if (is_a($exception'start', 'DateTime')) {
+                    $exstart = $this->_convert_datetime($exception'start');
+                    if ($exstart < $sql_data'dtstart') {
+                        $sql_data'dtstart' = $exstart;
+                    }
+                }
+                if (is_a($exception'end', 'DateTime')) {
+                    $exend = $this->_convert_datetime($exception'end');
+                    if ($exend > $sql_data'dtend') {
+                        $sql_data'dtend' = $exend;
+                    }
+                }
+            }
+        }
+
+        $sql_data'tags'  = ' ' . join(' ', $this->get_tags($object)) . ' ';  // pad with spaces for strict/prefix search
+        $sql_data'words' = ' ' . join(' ', $this->get_words($object)) . ' ';
+
+        return $sql_data;
+    }
+
+    /**
+     * Callback to get words to index for fulltext search
+     *
+     * @return array List of words to save in cache
+     */
+    public function get_words($object = )
+    {
+        $data = '';
+
+        foreach ($this->fulltext_cols as $colname) {
+            list($col, $field) = explode(':', $colname);
+
+            if ($field) {
+                $a = ;
+                foreach ((array) $object$col as $attr) {
+                    $a = $attr$field;
+                }
+                $val = join(' ', $a);
+            }
+            else {
+                $val = is_array($object$col) ? join(' ', $object$col) : $object$col;
+            }
+
+            if (strlen($val))
+                $data .= $val . ' ';
+        }
+
+        $words = rcube_utils::normalize_string($data, true);
+
+        // collect words from recurrence exceptions
+        if (is_array($object'exceptions')) {
+            foreach ($object'exceptions' as $exception) {
+                $words = array_merge($words, $this->get_words($exception));
+            }
+        }
+
+        return array_unique($words);
+    }
+
+    /**
+     * Callback to get object specific tags to cache
+     *
+     * @return array List of tags to save in cache
+     */
+    public function get_tags($object)
+    {
+        $tags = ;
+
+        if (!empty($object'valarms')) {
+            $tags = 'x-has-alarms';
+        }
+
+        // create tags reflecting participant status
+        if (is_array($object'attendees')) {
+            foreach ($object'attendees' as $attendee) {
+                if (!empty($attendee'email') && !empty($attendee'status'))
+                    $tags = 'x-partstat:' . $attendee'email' . ':' . strtolower($attendee'status');
+            }
+        }
+
+        // collect tags from recurrence exceptions
+        if (is_array($object'exceptions')) {
+            foreach ($object'exceptions' as $exception) {
+                $tags = array_merge($tags, $this->get_tags($exception));
+            }
+        }
+
+        if (!empty($object'status')) {
+          $tags = 'x-status:' . strtolower($object'status');
+        }
+
+        return array_unique($tags);
+    }
+}

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_dav_folder.php Added

@@ -0,0 +1,586 @@
+<?php
+
+/**
+ * A class representing a DAV folder object.
+ *
+ * @author Aleksander Machniak <machniak@apheleia-it.ch>
+ *
+ * Copyright (C) 2014-2022, Apheleia IT AG <contact@apheleia-it.ch>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * 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 kolab_storage_dav_folder extends kolab_storage_folder
+{
+    public $dav;
+    public $href;
+    public $attributes;
+
+    /**
+     * Object constructor
+     */
+    public function __construct($dav, $attributes, $type_annotation = '')
+    {
+        $this->attributes = $attributes;
+
+        $this->href  = $this->attributes'href';
+        $this->id    = md5($this->href);
+        $this->dav   = $dav;
+        $this->valid = true;
+
+        list($this->type, $suffix) = explode('.', $type_annotation);
+        $this->default = $suffix == 'default';
+        $this->subtype = $this->default ? '' : $suffix;
+
+        // Init cache
+        $this->cache = kolab_storage_dav_cache::factory($this);
+    }
+
+    /**
+     * Returns the owner of the folder.
+     *
+     * @param bool Return a fully qualified owner name (i.e. including domain for shared folders)
+     *
+     * @return string The owner of this folder.
+     */
+    public function get_owner($fully_qualified = false)
+    {
+        // return cached value
+        if (isset($this->owner)) {
+            return $this->owner;
+        }
+
+        $rcube = rcube::get_instance();
+        $this->owner = $rcube->get_user_name();
+        $this->valid = true;
+
+        // TODO: Support shared folders
+
+        return $this->owner;
+    }
+
+    /**
+     * Get a folder Etag identifier
+     */
+    public function get_ctag()
+    {
+        return $this->attributes'ctag';
+    }
+
+    /**
+     * Getter for the name of the namespace to which the folder belongs
+     *
+     * @return string Name of the namespace (personal, other, shared)
+     */
+    public function get_namespace()
+    {
+        // TODO: Support shared folders
+        return 'personal';
+    }
+
+    /**
+     * Get the display name value of this folder
+     *
+     * @return string Folder name
+     */
+    public function get_name()
+    {
+        return kolab_storage_dav::object_name($this->attributes'name');
+    }
+
+    /**
+     * Getter for the top-end folder name (not the entire path)
+     *
+     * @return string Name of this folder
+     */
+    public function get_foldername()
+    {
+        return $this->attributes'name';
+    }
+
+    public function get_folder_info()
+    {
+        return ; // todo ?
+    }
+
+    /**
+     * Getter for parent folder path
+     *
+     * @return string Full path to parent folder
+     */
+    public function get_parent()
+    {
+        // TODO
+        return '';
+    }
+
+    /**
+     * Compose a unique resource URI for this folder
+     */
+    public function get_resource_uri()
+    {
+        if (!empty($this->resource_uri)) {
+            return $this->resource_uri;
+        }
+
+        // compose fully qualified resource uri for this instance
+        $host = preg_replace('|^https?://|', 'dav://' . urlencode($this->get_owner(true)) . '@', $this->dav->url);
+        $path = $this->href0 == '/' ? $this->href : "/{$this->href}";
+
+        $host_path = parse_url($host, PHP_URL_PATH);
+        if ($host_path && strpos($path, $host_path) === 0) {
+            $path = substr($path, strlen($host_path));
+        }
+
+        $this->resource_uri = unslashify($host) . $path;
+
+        return $this->resource_uri;
+    }
+
+    /**
+     * Getter for the Cyrus mailbox identifier corresponding to this folder
+     * (e.g. user/john.doe/Calendar/Personal@example.org)
+     *
+     * @return string Mailbox ID
+     */
+    public function get_mailbox_id()
+    {
+        // TODO: This is used with Bonnie related features
+        return '';
+    }
+
+    /**
+     * Get the color value stored in metadata
+     *
+     * @param string Default color value to return if not set
+     *
+     * @return mixed Color value from the folder metadata or $default if not set
+     */
+    public function get_color($default = null)
+    {
+        return !empty($this->attributes'color') ? $this->attributes'color' : $default;
+    }
+
+    /**
+     * Get ACL information for this folder
+     *
+     * @return string Permissions as string
+     */
+    public function get_myrights()
+    {
+        // TODO
+        return '';
+    }
+
+    /**
+     * Helper method to extract folder UID
+     *
+     * @return string Folder's UID
+     */
+    public function get_uid()
+    {
+        // TODO ???
+        return '';
+    }
+
+    /**
+     * Check activation status of this folder
+     *
+     * @return bool True if enabled, false if not

roundcubemail-1.5.3.tar.gz/plugins/libkolab/lib/kolab_storage_folder.php Changed

roundcubemail-1.5.3.tar.gz/plugins/libkolab/libkolab.php Changed

roundcubemail-1.5.3.tar.gz/temp/js_cache/tinymce-langs-5.8.2.zip Changed

roundcubemail-1.5.3.tar.gz/vendor/autoload.php Changed

roundcubemail-1.5.3.tar.gz/vendor/composer/autoload_real.php Changed

@@ -2,7 +2,7 @@
 
 // autoload_real.php @generated by Composer
 
-class ComposerAutoloaderInit2f7d7a156ef8bcd5dd309bbede2aff2e
+class ComposerAutoloaderInit2d63d1baaa346936e29de4a7fd860062
 {
     private static $loader;
 
@@ -24,9 +24,9 @@
 
         require __DIR__ . '/platform_check.php';
 
-        spl_autoload_register(array('ComposerAutoloaderInit2f7d7a156ef8bcd5dd309bbede2aff2e', 'loadClassLoader'), true, true);
+        spl_autoload_register(array('ComposerAutoloaderInit2d63d1baaa346936e29de4a7fd860062', 'loadClassLoader'), true, true);
         self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(\dirname(__FILE__)));
-        spl_autoload_unregister(array('ComposerAutoloaderInit2f7d7a156ef8bcd5dd309bbede2aff2e', 'loadClassLoader'));
+        spl_autoload_unregister(array('ComposerAutoloaderInit2d63d1baaa346936e29de4a7fd860062', 'loadClassLoader'));
 
         $includePaths = require __DIR__ . '/include_paths.php';
         $includePaths = get_include_path();
@@ -36,7 +36,7 @@
         if ($useStaticLoader) {
             require __DIR__ . '/autoload_static.php';
 
-            call_user_func(\Composer\Autoload\ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e::getInitializer($loader));
+            call_user_func(\Composer\Autoload\ComposerStaticInit2d63d1baaa346936e29de4a7fd860062::getInitializer($loader));
         } else {
             $map = require __DIR__ . '/autoload_namespaces.php';
             foreach ($map as $namespace => $path) {
@@ -57,19 +57,19 @@
         $loader->register(true);
 
         if ($useStaticLoader) {
-            $includeFiles = Composer\Autoload\ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e::$files;
+            $includeFiles = Composer\Autoload\ComposerStaticInit2d63d1baaa346936e29de4a7fd860062::$files;
         } else {
             $includeFiles = require __DIR__ . '/autoload_files.php';
         }
         foreach ($includeFiles as $fileIdentifier => $file) {
-            composerRequire2f7d7a156ef8bcd5dd309bbede2aff2e($fileIdentifier, $file);
+            composerRequire2d63d1baaa346936e29de4a7fd860062($fileIdentifier, $file);
         }
 
         return $loader;
     }
 }
 
-function composerRequire2f7d7a156ef8bcd5dd309bbede2aff2e($fileIdentifier, $file)
+function composerRequire2d63d1baaa346936e29de4a7fd860062($fileIdentifier, $file)
 {
     if (empty($GLOBALS'__composer_autoload_files'$fileIdentifier)) {
         require $file;

roundcubemail-1.5.3.tar.gz/vendor/composer/autoload_static.php Changed

@@ -4,7 +4,7 @@
 
 namespace Composer\Autoload;
 
-class ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e
+class ComposerStaticInit2d63d1baaa346936e29de4a7fd860062
 {
     public static $files = array (
         '320cde22f66dd4f5d3fd621d3e88b98f' => __DIR__ . '/..' . '/symfony/polyfill-ctype/bootstrap.php',
@@ -931,11 +931,11 @@
     public static function getInitializer(ClassLoader $loader)
     {
         return \Closure::bind(function () use ($loader) {
-            $loader->prefixLengthsPsr4 = ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e::$prefixLengthsPsr4;
-            $loader->prefixDirsPsr4 = ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e::$prefixDirsPsr4;
-            $loader->prefixesPsr0 = ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e::$prefixesPsr0;
-            $loader->fallbackDirsPsr0 = ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e::$fallbackDirsPsr0;
-            $loader->classMap = ComposerStaticInit2f7d7a156ef8bcd5dd309bbede2aff2e::$classMap;
+            $loader->prefixLengthsPsr4 = ComposerStaticInit2d63d1baaa346936e29de4a7fd860062::$prefixLengthsPsr4;
+            $loader->prefixDirsPsr4 = ComposerStaticInit2d63d1baaa346936e29de4a7fd860062::$prefixDirsPsr4;
+            $loader->prefixesPsr0 = ComposerStaticInit2d63d1baaa346936e29de4a7fd860062::$prefixesPsr0;
+            $loader->fallbackDirsPsr0 = ComposerStaticInit2d63d1baaa346936e29de4a7fd860062::$fallbackDirsPsr0;
+            $loader->classMap = ComposerStaticInit2d63d1baaa346936e29de4a7fd860062::$classMap;
 
         }, null, ClassLoader::class);
     }