kalarm/resources/resourceremote.cpp

   1 /*
   2  *  resourceremote.cpp  -  KAlarm remote alarm calendar resource
   3  *  Program:  kalarm
   4  *  Copyright © 2006-2011 by David Jarvie <djarvie@kde.org>
   5  *  Based on resourceremote.cpp in kresources (updated to rev 721447),
   6  *  Copyright (c) 2003,2004 Cornelius Schumacher <schumacher@kde.org>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21  */
  22
  23 #include "kalarm.h"
  24
  25 #include "resourceremote.moc"
  26
  27 //#include <libkdepim/progressmanager.h>
  28 #include <kcal/calendarlocal.h>
  29
  30 #include <kio/job.h>
  31 #include <kio/jobuidelegate.h>
  32 #include <kio/jobclasses.h>
  33 #include <klocale.h>
  34 #include <kstandarddirs.h>
  35
  36 using namespace KCal;
  37
  38
  39 KAResourceRemote::KAResourceRemote()
  40     : AlarmResource(),
  41       mDownloadJob(0),
  42       mUploadJob(0),
  43       mShowProgress(true),
  44       mUseCacheFile(true),
  45       mRemoteReadOnly(false)
  46 {
  47     init();
  48 }
  49
  50 KAResourceRemote::KAResourceRemote(const KConfigGroup& group)
  51     : AlarmResource(group),
  52       mDownloadJob(0),
  53       mUploadJob(0),
  54       mShowProgress(true),
  55       mUseCacheFile(true),
  56       mRemoteReadOnly(false)
  57 {
  58     mDownloadUrl = KUrl(group.readEntry("DownloadUrl"));
  59     mUploadUrl = KUrl(group.readEntry("UploadUrl"));
  60     ResourceCached::readConfig(group );
  61     init();
  62 }
  63
  64 KAResourceRemote::KAResourceRemote(CalEvent::Type type, const KUrl& downloadUrl, const KUrl& uploadUrl)
  65     : AlarmResource(type),
  66       mDownloadUrl(downloadUrl),
  67       mUploadUrl(uploadUrl.isEmpty() ? mDownloadUrl : uploadUrl),
  68       mDownloadJob(0),
  69       mUploadJob(0),
  70       mShowProgress(false),
  71       mUseCacheFile(false),
  72       mRemoteReadOnly(false)
  73 {
  74     init();
  75 }
  76
  77 void KAResourceRemote::init()
  78 {
  79     setType("remote");   // set resource type
  80     lock(cacheFile());
  81 }
  82
  83 KAResourceRemote::~KAResourceRemote()
  84 {
  85     if (isOpen())
  86         close();
  87 }
  88
  89 void KAResourceRemote::doClose()
  90 {
  91     cancelDownload();
  92     if (mUploadJob)
  93     {
  94         mUploadJob->kill();
  95         mUploadJob = 0;
  96     }
  97     AlarmResource::doClose();
  98 }
  99
 100 void KAResourceRemote::writeConfig(KConfigGroup& group)
 101 {
 102     group.writeEntry("DownloadUrl", mDownloadUrl.url());
 103     group.writeEntry("UploadUrl", mUploadUrl.url());
 104     AlarmResource::writeConfig(group);
 105 }
 106
 107 void KAResourceRemote::startReconfig()
 108 {
 109     mNewDownloadUrl = mDownloadUrl;
 110     mNewUploadUrl   = mUploadUrl;
 111     AlarmResource::startReconfig();
 112 }
 113
 114 void KAResourceRemote::applyReconfig()
 115 {
 116     if (mReconfiguring)
 117     {
 118         AlarmResource::applyReconfig();
 119         if (setUrls(mNewDownloadUrl, mNewUploadUrl))
 120             mReconfiguring = 3;    // indicate that location has changed
 121         AlarmResource::applyReconfig();
 122     }
 123 }
 124
 125 bool KAResourceRemote::readOnly() const
 126 {
 127     return mRemoteReadOnly || AlarmResource::readOnly();
 128 }
 129
 130 void KAResourceRemote::enableResource(bool enable)
 131 {
 132     if (!enable)
 133         cancelDownload(false);
 134 }
 135
 136 bool KAResourceRemote::doLoad(bool syncCache)
 137 {
 138     if (mUploadJob)
 139         syncCache = false;   // still uploading, so the cache is up-to-date
 140     if (mDownloadJob)
 141     {
 142         kWarning(KARES_DEBUG) << "Download still in progress";
 143         return true;
 144     }
 145     mLoaded = false;
 146     emit invalidate(this);
 147     calendar()->close();
 148     setWrongAlarmType(false, false);
 149     clearChanges();
 150     if (!isActive())
 151     {
 152         updateCustomEvents(false);   // calendar is now empty
 153         return false;
 154     }
 155     mLoading = true;
 156
 157     if (mUseCacheFile  ||  !syncCache)
 158     {
 159         disableChangeNotification();
 160         syncCache = !loadFromCache();    // if cache file doesn't exist yet, we need to download
 161         mUseCacheFile = false;
 162         enableChangeNotification();
 163     }
 164     emit resourceChanged(this);
 165
 166     if (!syncCache)
 167     {
 168         kDebug(KARES_DEBUG) << mDownloadUrl.prettyUrl() << ": from cache";
 169         slotLoadJobResult(0);
 170     }
 171     else if (!lock()->lock())
 172     {
 173         kDebug(KARES_DEBUG) << mDownloadUrl.prettyUrl() << ": cache file is locked - something else must be loading the file";
 174         updateCustomEvents();
 175     }
 176     else
 177     {
 178         kDebug(KARES_DEBUG) << mDownloadUrl.prettyUrl() << ": downloading...";
 179         mDownloadJob = KIO::file_copy(mDownloadUrl, KUrl(cacheFile()), -1, KIO::Overwrite |
 180             ((mShowProgress && hasGui()) ? KIO::DefaultFlags : KIO::HideProgressInfo));
 181         connect(mDownloadJob, SIGNAL(result(KJob*)), SLOT(slotLoadJobResult(KJob*)));
 182 #if 0
 183         if (mShowProgress  &&  hasGui())
 184         {
 185             connect(mDownloadJob, SIGNAL(percent(KJob*,ulong)),
 186                           SLOT(slotPercent(KJob*,ulong)));
 187             emit downloading(this, 0);
 188         }
 189 #endif
 190     }
 191     return true;
 192 }
 193
 194 void KAResourceRemote::slotPercent(KJob*, unsigned long percent)
 195 {
 196     Q_UNUSED(percent);
 197 #if 0
 198     emit downloading(this, percent);
 199 #endif
 200 }
 201
 202 void KAResourceRemote::slotLoadJobResult(KJob* job)
 203 {
 204     bool err = false;
 205     if (job)
 206     {
 207         emit invalidate(this);
 208         calendar()->close();
 209         setWrongAlarmType(false, false);
 210         clearChanges();
 211         if (job->error())
 212         {
 213             if (hasGui())
 214             {
 215                 KIO::FileCopyJob* j = qobject_cast<KIO::FileCopyJob*>(job);
 216                 if (j)
 217                     j->ui()->showErrorMessage();
 218             }
 219             kError(KARES_DEBUG) << "Resource" << identifier() << " download error:" << job->errorString();
 220             setEnabled(false);
 221             err = true;
 222         }
 223         else
 224         {
 225             kDebug(KARES_DEBUG) << mDownloadUrl.prettyUrl() << ": success";
 226             setReloaded(true);    // the resource has now been downloaded at least once
 227             emit cacheDownloaded(this);
 228             disableChangeNotification();
 229             loadFromCache();
 230             enableChangeNotification();
 231         }
 232
 233 #if 0
 234         emit downloading(this, (unsigned long)-1);
 235 #endif
 236     }
 237     mDownloadJob = 0;
 238
 239     if (!err)
 240     {
 241         checkCompatibility(cacheFile());
 242         mLoaded = true;
 243     }
 244     mLoading = false;
 245     lock()->unlock();
 246     updateCustomEvents();
 247     emit loaded(this);
 248     if (job  &&  !err)
 249         emit resourceChanged(this);
 250 }
 251
 252 void KAResourceRemote::cancelDownload(bool disable)
 253 {
 254     if (mDownloadJob)
 255     {
 256         mDownloadJob->kill();
 257         mDownloadJob = 0;
 258         if (disable)
 259             setEnabled(false);
 260 #if 0
 261         emit downloading(this, (unsigned long)-1);
 262 #endif
 263         mLoading = false;
 264         lock()->unlock();
 265         updateCustomEvents();
 266         emit loaded(this);
 267     }
 268 }
 269
 270 bool KAResourceRemote::doSave(bool syncCache)
 271 {
 272     kDebug(KARES_DEBUG) << mUploadUrl.prettyUrl();
 273     if (readOnly()  ||  !hasChanges())
 274         return true;
 275     if (mDownloadJob)
 276     {
 277         kWarning(KARES_DEBUG) << "Download still in progress";
 278         return false;
 279     }
 280     if (mUploadJob)
 281     {
 282         kWarning(KARES_DEBUG) << "Upload still in progress";
 283         return false;
 284     }
 285
 286     mChangedIncidences = allChanges();
 287     if (mCalIDFunction)
 288         (*mCalIDFunction)(*calendar());    // write the application ID into the calendar
 289     saveToCache();
 290     if (syncCache)
 291     {
 292         mUploadJob = KIO::file_copy(KUrl(cacheFile()), mUploadUrl, -1, KIO::Overwrite | (hasGui()?KIO::DefaultFlags:KIO::HideProgressInfo));
 293         connect(mUploadJob, SIGNAL(result(KJob*)), SLOT(slotSaveJobResult(KJob*)));
 294     }
 295     return true;
 296 }
 297
 298 void KAResourceRemote::slotSaveJobResult(KJob* job)
 299 {
 300     if (job->error())
 301     {
 302         if (hasGui())
 303         {
 304             KIO::FileCopyJob* j = qobject_cast<KIO::FileCopyJob*>(job);
 305             if (j)
 306                 j->ui()->showErrorMessage();
 307         }
 308         kError(KARES_DEBUG) << "Resource" << identifier() << " upload error:" << job->errorString();
 309     }
 310     else
 311     {
 312         kDebug(KARES_DEBUG) << mUploadUrl.prettyUrl() << ": success";
 313         clearChanges();
 314     }
 315
 316     mUploadJob = 0;
 317     emit resourceSaved(this);
 318     if (closeAfterSave())
 319         close();
 320 }
 321
 322 bool KAResourceRemote::setUrls(const KUrl& downloadUrl, const KUrl& uploadUrl)
 323 {
 324     if (mReconfiguring == 1)
 325     {
 326         mNewDownloadUrl = downloadUrl;
 327         mNewUploadUrl   = uploadUrl;
 328         return true;
 329     }
 330     if (downloadUrl.equals(mDownloadUrl)
 331     &&  uploadUrl.equals(mUploadUrl))
 332         return false;
 333     kDebug(KARES_DEBUG) << downloadUrl.prettyUrl() << "," << uploadUrl.prettyUrl();
 334     if (isOpen())
 335         close();
 336     bool active = isActive();
 337     if (active)
 338         enableResource(false);
 339     mDownloadUrl = downloadUrl;
 340     mUploadUrl   = uploadUrl;
 341     if (active)
 342         enableResource(true);
 343     // Trigger loading the new resource, and ensure that the new configuration is saved
 344     emit locationChanged(this);
 345     return true;
 346 }
 347
 348 bool KAResourceRemote::setLocation(const QString& downloadUrl, const QString& uploadUrl)
 349 {
 350     return setUrls(KUrl(downloadUrl), KUrl(uploadUrl));
 351 }
 352
 353 QStringList KAResourceRemote::location() const
 354 {
 355     return QStringList(downloadUrl().url()) << uploadUrl().url();
 356 }
 357
 358 QString KAResourceRemote::displayLocation() const
 359 {
 360     return mDownloadUrl.prettyUrl();
 361 }
 362
 363 QString KAResourceRemote::displayType() const
 364 {
 365     return i18nc("@info/plain", "URL");
 366 }
 367
 368 // vim: et sw=4: