You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdepim/kresources/remote/resourceremote.cpp

353 lines
8.4 KiB

/*
This file is part of libkcal.
Copyright (c) 2003,2004 Cornelius Schumacher <schumacher@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include <typeinfo>
#include <stdlib.h>
#include <tqdatetime.h>
#include <tqstring.h>
#include <tqptrlist.h>
#include <kdebug.h>
#include <kurl.h>
#include <kio/job.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <kstandarddirs.h>
#include <libkcal/icalformat.h>
#include <libkcal/exceptions.h>
#include <libkcal/incidence.h>
#include <libkcal/event.h>
#include <libkcal/todo.h>
#include <libkcal/journal.h>
#include <libkcal/filestorage.h>
#include <kabc/lock.h>
#include <kresources/configwidget.h>
#include "resourceremoteconfig.h"
#include "resourceremote.h"
using namespace KCal;
ResourceRemote::ResourceRemote( const KConfig *config )
: ResourceCached( config ), mUseProgressManager( true ), mUseCacheFile( true )
{
if ( config ) {
readConfig( config );
} else {
setResourceName( i18n( "Remote Calendar" ) );
}
init();
}
ResourceRemote::ResourceRemote( const KURL &downloadUrl, const KURL &uploadUrl )
: ResourceCached( 0 ), mUseProgressManager( false ), mUseCacheFile( false )
{
mDownloadUrl = downloadUrl;
if ( uploadUrl.isEmpty() ) {
mUploadUrl = mDownloadUrl;
} else {
mUploadUrl = uploadUrl;
}
init();
}
ResourceRemote::~ResourceRemote()
{
close();
if ( mDownloadJob ) mDownloadJob->kill();
if ( mUploadJob ) mUploadJob->kill();
delete mLock;
}
void ResourceRemote::init()
{
mDownloadJob = 0;
mUploadJob = 0;
mProgress = 0;
setType( "remote" );
mLock = new KABC::Lock( cacheFile() );
enableChangeNotification();
}
void ResourceRemote::readConfig( const KConfig *config )
{
TQString url = config->readEntry( "DownloadUrl" );
mDownloadUrl = KURL( url );
url = config->readEntry( "UploadUrl" );
mUploadUrl = KURL( url );
ResourceCached::readConfig( config );
}
void ResourceRemote::writeConfig( KConfig *config )
{
kdDebug(5800) << "ResourceRemote::writeConfig()" << endl;
ResourceCalendar::writeConfig( config );
config->writeEntry( "DownloadUrl", mDownloadUrl.url() );
config->writeEntry( "UploadUrl", mUploadUrl.url() );
ResourceCached::writeConfig( config );
}
void ResourceRemote::setDownloadUrl( const KURL &url )
{
mDownloadUrl = url;
}
KURL ResourceRemote::downloadUrl() const
{
return mDownloadUrl;
}
void ResourceRemote::setUploadUrl( const KURL &url )
{
mUploadUrl = url;
}
KURL ResourceRemote::uploadUrl() const
{
return mUploadUrl;
}
void ResourceRemote::setUseProgressManager( bool useProgressManager )
{
mUseProgressManager = useProgressManager;
}
bool ResourceRemote::useProgressManager() const
{
return mUseProgressManager;
}
void ResourceRemote::setUseCacheFile( bool useCacheFile )
{
mUseCacheFile = useCacheFile;
}
bool ResourceRemote::useCacheFile() const
{
return mUseCacheFile;
}
bool ResourceRemote::doLoad()
{
kdDebug(5800) << "ResourceRemote::load()" << endl;
if ( mDownloadJob ) {
kdWarning() << "ResourceRemote::load(): download still in progress."
<< endl;
return true;
}
if ( mUploadJob ) {
kdWarning() << "ResourceRemote::load(): upload still in progress."
<< endl;
return false;
}
mCalendar.close();
if ( mUseCacheFile ) {
disableChangeNotification();
loadCache();
enableChangeNotification();
}
clearChanges();
emit resourceChanged( this );
if ( mLock->lock() )
{
kdDebug() << "Download from: " << mDownloadUrl << endl;
mDownloadJob = KIO::file_copy( mDownloadUrl, KURL( cacheFile() ), -1, true,
false, !mUseProgressManager );
connect( mDownloadJob, TQT_SIGNAL( result( KIO::Job * ) ),
TQT_SLOT( slotLoadJobResult( KIO::Job * ) ) );
if ( mUseProgressManager ) {
connect( mDownloadJob, TQT_SIGNAL( percent( KIO::Job *, unsigned long ) ),
TQT_SLOT( slotPercent( KIO::Job *, unsigned long ) ) );
mProgress = KPIM::ProgressManager::createProgressItem(
KPIM::ProgressManager::getUniqueID(), i18n("Downloading Calendar") );
mProgress->setProgress( 0 );
}
}
else
kdDebug() << "ResourceRemote::load(): cache file is locked - something else must be loading the file" << endl;
return true;
}
void ResourceRemote::slotPercent( KIO::Job *, unsigned long percent )
{
kdDebug() << "ResourceRemote::slotPercent(): " << percent << endl;
mProgress->setProgress( percent );
}
void ResourceRemote::slotLoadJobResult( KIO::Job *job )
{
if ( job->error() ) {
// TODO: Should detect 404, 401 etc. vs host not found and prompt to create new resource only when 404 is returned
TQString warningString = TQString("<b>") + i18n("Remote data access failure") + TQString("</b><p>") + i18n("Detailed information") \
+ TQString(":<br>") + job->errorString() + TQString("<p>") + i18n("What would you like to do?");
int rc = KMessageBox::warningContinueCancel(0,
warningString, i18n("Remote Data Access Failure"), i18n("&Continue with cached resource"));
if ( rc == KMessageBox::Continue ) {
mCalendar.close();
disableChangeNotification();
loadCache();
enableChangeNotification();
emit resourceChanged( this );
}
//job->showErrorDialog( 0 );
} else {
kdDebug(5800) << "ResourceRemote::slotLoadJobResult() success" << endl;
mCalendar.close();
disableChangeNotification();
loadCache();
enableChangeNotification();
emit resourceChanged( this );
}
mDownloadJob = 0;
if ( mProgress ) {
mProgress->setComplete();
mProgress = 0;
}
mLock->unlock();
emit resourceLoaded( this );
}
bool ResourceRemote::doSave()
{
kdDebug(5800) << "ResourceRemote::save()" << endl;
if ( readOnly() || !hasChanges() ) {
emit resourceSaved( this );
return true;
}
if ( mDownloadJob ) {
kdWarning() << "ResourceRemote::save(): download still in progress."
<< endl;
return false;
}
if ( mUploadJob ) {
kdWarning() << "ResourceRemote::save(): upload still in progress."
<< endl;
return false;
}
mChangedIncidences = allChanges();
saveCache();
mUploadJob = KIO::file_copy( KURL( cacheFile() ), mUploadUrl, -1, true );
connect( mUploadJob, TQT_SIGNAL( result( KIO::Job * ) ),
TQT_SLOT( slotSaveJobResult( KIO::Job * ) ) );
return true;
}
bool ResourceRemote::isSaving()
{
return mUploadJob;
}
void ResourceRemote::slotSaveJobResult( KIO::Job *job )
{
if ( job->error() ) {
job->showErrorDialog( 0 );
} else {
kdDebug(5800) << "ResourceRemote::slotSaveJobResult() success" << endl;
Incidence::List::ConstIterator it;
for( it = mChangedIncidences.begin(); it != mChangedIncidences.end();
++it ) {
clearChange( *it );
}
mChangedIncidences.clear();
}
mUploadJob = 0;
emit resourceSaved( this );
}
KABC::Lock *ResourceRemote::lock()
{
return mLock;
}
void ResourceRemote::dump() const
{
ResourceCalendar::dump();
kdDebug(5800) << " DownloadUrl: " << mDownloadUrl.url() << endl;
kdDebug(5800) << " UploadUrl: " << mUploadUrl.url() << endl;
kdDebug(5800) << " ReloadPolicy: " << reloadPolicy() << endl;
}
void ResourceRemote::addInfoText( TQString &txt ) const
{
txt += "<br>";
txt += i18n("URL: %1").arg( mDownloadUrl.prettyURL() );
}
bool ResourceRemote::setValue( const TQString &key, const TQString &value )
{
if ( key == "URL" ) {
setUploadUrl( KURL( value ) );
setDownloadUrl( KURL( value ) );
return true;
} else if ( key == "DownloadURL" ) {
setDownloadUrl( KURL( value ) );
return true;
} else if ( key == "UploadURL" ) {
setUploadUrl( KURL( value ) );
return true;
} else
return ResourceCached::setValue( key, value );
}
#include "resourceremote.moc"