~ubuntu-branches/ubuntu/natty/kdebase-runtime/natty-proposed

#include "standardqueries.h"

#include "resourcestat.h"

#include <Nepomuk/Vocabulary/NFO>

#include <Nepomuk/Vocabulary/NIE>

#include <Nepomuk/Vocabulary/PIMO>

        uds.insert( KIO::UDSEntry::UDS_DISPLAY_TYPE, i18n( "Query folder" ) );

        uds.insert( KIO::UDSEntry::UDS_NAME, Nepomuk::Query::Query::titleFromQueryUrl( url ) );

        if ( url.hasQueryItem( QLatin1String( "resource" ) ) ) {

            Nepomuk::addGenericNepomukResourceData( Nepomuk::Resource( KUrl( url.queryItemValue( QLatin1String( "resource" ) ) ) ), uds );

        }

        Nepomuk::Query::Query query = Nepomuk::Query::Query::fromQueryUrl( url );

        if ( query.isValid() )

            uds.insert( KIO::UDSEntry::UDS_NEPOMUK_QUERY, query.toString() );

 

    // a query folder has a non-empty path with a single section and a query parameter

    // Example: nepomuksearch:/My Query?query=foobar

    bool isQueryFolder( const KUrl& url ) {

        return( url.hasQuery() &&

                url.directory() == QLatin1String("/") );

    }

 

    // Legacy query URLs look like: nepomuksearch:/?query=xyz&title=foobar

    // i.e. an empty path and a query, new URLs have their title as path

    bool isLegacyQueryUrl( const KUrl& url ) {

        const QString path = url.path(KUrl::RemoveTrailingSlash);

        return( url.hasQuery() &&

                ( path.isEmpty() || path == QLatin1String("/") ) );

    }

 

    KUrl convertLegacyQueryUrl( const KUrl& url ) {

        KUrl newUrl(QLatin1String("nepomuksearch:/") + Nepomuk::Query::Query::titleFromQueryUrl(url));

        Nepomuk::Query::Query query = Nepomuk::Query::Query::fromQueryUrl(url);

        if(query.isValid())

            newUrl.addQueryItem(QLatin1String("encodedquery"), query.toString());

        else

            newUrl.addQueryItem(QLatin1String("sparql"), Nepomuk::Query::Query::sparqlFromQueryUrl(url));

        return newUrl;

    }

 

    Nepomuk::Query::Query rootQuery() {

        KConfig config( "kio_nepomuksearchrc" );

        QString queryStr = config.group( "General" ).readEntry( "Root query", QString() );

        Nepomuk::Query::Query query;

        if ( queryStr.isEmpty() )

            query = Nepomuk::lastModifiedFilesQuery();

        else

            query = Nepomuk::Query::Query::fromString( queryStr );

        query.setLimit( config.group( "General" ).readEntry( "Root query limit", 10 ) );

        return query;

    }

    // list the root folder

 

    // backwards compatibility with pre-4.6 query URLs

    else if( isLegacyQueryUrl( url ) ) {

        redirection( convertLegacyQueryUrl(url) );

        finished();

    }

 

    // list the actual query folders

    else if( isQueryFolder( url ) ) {

            updateQueryUrlHistory( url );

 

    // listing of query results that are folders

    else {

        ForwardingSlaveBase::listDir(url);

    }

    // the root url is always a folder

 

    // Query result URLs in the root folder do not include a query

    // while all query folders do. The latter ones are what we check

    // for here.

    else if ( url.directory() == QLatin1String( "/" ) &&

              url.hasQuery() ) {

 

    // results are forwarded

    // the root folder

        uds.insert( KIO::UDSEntry::UDS_NEPOMUK_QUERY, rootQuery().toString() );

 

    // query folders

    else if( isQueryFolder( url ) ) {

 

    // results are forwarded

    ForwardingSlaveBase::del( url, isFile );

void Nepomuk::SearchProtocol::prepareUDSEntry( KIO::UDSEntry& uds, bool listing ) const

    // for performace reasons we do encode the result's resource URI in the UDS_NAME

    // Otherwise we would have to re-query for each stat operation

    // This is simple for "direct" query results (SearchFolder takes care of that)

    // but a bit harder for items in results that are folders.

    // In the latter case we get the parent folder's resource URI (which is encoded in

    // the UDS_NAME) and append the filename.

    //

    // Also note that results listed via a SearchFolder will never go through this method

    // since they are listed directly and not via a forward. Forwarding will only happen

    // for search results that are folders and for non-listing operations.

 

    kDebug() << requestedUrl() << processedUrl() << uds.stringValue(KIO::UDSEntry::UDS_NAME);

    const QString name = uds.stringValue(KIO::UDSEntry::UDS_NAME);

    if(name != QLatin1String(".") && name != QLatin1String("..")) {

        // let the ForwardingSlaveBase create UDS_LOCAL_PATH and mimetype entries

        // This call depends on the original UDS_NAME which we change below. Thus, it

        // is important to let ForwardingSlaveBase do its thing before we start ours

        ForwardingSlaveBase::prepareUDSEntry( uds, listing );

 

        // encode the URL in the UDS_NAME to prevent a re-query in stat and friends

        KUrl resourceUrl(processedUrl());

        if(listing) {

            resourceUrl.addPath(name);

        }

        uds.insert(KIO::UDSEntry::UDS_NAME, Nepomuk::resourceUriToUdsName(resourceUrl));

        if ( !uds.contains( KIO::UDSEntry::UDS_DISPLAY_NAME ) ) {

            uds.insert(KIO::UDSEntry::UDS_DISPLAY_NAME, name);

        }

 

        // There is a trade-off between using UDS_TARGET_URL or not. The advantage is that we get proper

        // file names in opening applications and non-KDE apps can handle the URLs properly. The downside

        // is that we lose the context information, i.e. query results cannot be browsed in the opening

        // application. We decide pro-filenames and pro-non-kde-apps here.

        if( resourceUrl.isLocalFile() ) {

            if ( uds.isDir() ) {

                Query::FileQuery query;

                query.addIncludeFolder( resourceUrl );

                uds.insert( KIO::UDSEntry::UDS_NEPOMUK_QUERY, query.toString() );

            }

            else {

                uds.insert( KIO::UDSEntry::UDS_TARGET_URL, resourceUrl.url() );

            }

        }

    }

    // flush

    listEntry( KIO::UDSEntry(), true );

 

    Query::Query query = rootQuery();

    if ( query.isValid() ) {

        getQueryFolder( query.toSearchUrl() )->list();

    }

 

    return new SearchFolder( url, this );

}

 

 

void Nepomuk::SearchProtocol::updateQueryUrlHistory( const KUrl& url )

{

    //

    // if the url is already in the history update its timestamp

    // otherwise remove the last item if we reached the max and then

    // add the url along with its timestamp

    //

    KSharedConfigPtr cfg = KSharedConfig::openConfig( "kio_nepomuksearchrc" );

    KConfigGroup grp = cfg->group( "Last Queries" );

 

    // read config

    const int cnt = grp.readEntry( "count", 0 );

    QList<QPair<KUrl, QDateTime> > entries;

    for ( int i = 0; i < cnt; ++i ) {

        KUrl u = grp.readEntry( QString::fromLatin1( "query_%1_url" ).arg( i ), QString() );

        QDateTime t = grp.readEntry( QString::fromLatin1( "query_%1_timestamp" ).arg( i ), QDateTime() );

        if ( !u.isEmpty() &&

             t.isValid() &&

             u != url ) {

            int pos = 0;

            while ( entries.count() > pos &&

                    entries[pos].second < t ) {

                ++pos;

            }

            entries.insert( pos, qMakePair( u, t ) );

        }

    }

    if ( entries.count() >= s_historyMax ) {

        entries.removeFirst();

    }

    entries.append( qMakePair( url, QDateTime::currentDateTime() ) );

 

    // write config back

    grp.deleteGroup();

    grp = cfg->group( "Last Queries" );

 

    for ( int i = 0; i < entries.count(); ++i ) {

        KUrl u = entries[i].first;

        QDateTime t = entries[i].second;

        grp.writeEntry( QString::fromLatin1( "query_%1_url" ).arg( i ), u.url() );

        grp.writeEntry( QString::fromLatin1( "query_%1_timestamp" ).arg( i ), t );

    }

    grp.writeEntry( QLatin1String( "count" ), entries.count() );

 

    cfg->sync();

 

#if 0

void Nepomuk::SearchProtocol::listUserQueries()

{

    UserQueryUrlList userQueries;

    Q_FOREACH( const KUrl& url, userQueries ) {

        KIO::UDSEntry uds = statSearchFolder( url );

        uds.insert( KIO::UDSEntry::UDS_DISPLAY_TYPE, i18n( "Saved Query" ) );

        listEntry( uds, false );

    }

}

void Nepomuk::SearchProtocol::listLastQueries()

{

    KSharedConfigPtr cfg = KSharedConfig::openConfig( "kio_nepomuksearchrc" );

    KConfigGroup grp = cfg->group( "Last Queries" );

 

    // read config

    const int cnt = grp.readEntry( "count", 0 );

    QList<QPair<KUrl, QDateTime> > entries;

    for ( int i = 0; i < cnt; ++i ) {

        KUrl u = grp.readEntry( QString::fromLatin1( "query_%1_url" ).arg( i ), QString() );

        QDateTime t = grp.readEntry( QString::fromLatin1( "query_%1_timestamp" ).arg( i ), QDateTime() );

        if ( !u.isEmpty() && t.isValid() )

            listEntry( statLastQuery( u, t ), false );

    }

 

    listEntry( KIO::UDSEntry(), true );

    finished();

}

#endif