← Back to branch summary

~ubuntu-branches/ubuntu/quantal/kde-runtime/quantal

« back to all changes in this revision

Viewing changes to nepomuk/kioslaves/search/kio_nepomuksearch.cpp

  • Committer: Package Import Robot
  • Author(s): Philip Muškovac
  • Date: 2012-06-03 21:50:00 UTC
  • mto: This revision was merged to the branch mainline in revision 21.
  • Revision ID: package-import@ubuntu.com-20120603215000-vn7oarsq0ynrydj5
Tags: upstream-4.8.80
Import upstream version 4.8.80

Show diffs side-by-side

added added

removed removed

Lines of Context:
nepomuk/kioslaves/search/kio_nepomuksearch.cpp
37
37
#include <KStandardDirs>
38
38
#include <KFileItem>
39
39
 
40
 
#include <Nepomuk/Thing>
41
 
#include <Nepomuk/ResourceManager>
42
 
#include <Nepomuk/Variant>
43
 
#include <Nepomuk/Query/QueryServiceClient>
44
 
#include <Nepomuk/Query/ComparisonTerm>
45
 
#include <Nepomuk/Query/ResourceTypeTerm>
46
 
#include <Nepomuk/Query/AndTerm>
47
 
#include <Nepomuk/Query/NegationTerm>
48
 
#include <Nepomuk/Query/Query>
 
40
#include <Nepomuk2/Thing>
 
41
#include <Nepomuk2/ResourceManager>
 
42
#include <Nepomuk2/Variant>
 
43
#include <Nepomuk2/Query/QueryServiceClient>
 
44
#include <Nepomuk2/Query/ComparisonTerm>
 
45
#include <Nepomuk2/Query/ResourceTypeTerm>
 
46
#include <Nepomuk2/Query/AndTerm>
 
47
#include <Nepomuk2/Query/NegationTerm>
 
48
#include <Nepomuk2/Query/Query>
49
49
 
50
50
#include <Soprano/Vocabulary/RDF>
51
51
#include <Soprano/Vocabulary/RDFS>
52
52
#include <Soprano/Vocabulary/NRL>
53
53
#include <Soprano/Vocabulary/NAO>
54
54
#include <Soprano/Vocabulary/XMLSchema>
55
 
#include <Nepomuk/Vocabulary/NFO>
56
 
#include <Nepomuk/Vocabulary/NIE>
57
 
#include <Nepomuk/Vocabulary/PIMO>
 
55
#include <Nepomuk2/Vocabulary/NFO>
 
56
#include <Nepomuk2/Vocabulary/NIE>
 
57
#include <Nepomuk2/Vocabulary/PIMO>
58
58
 
59
59
#include <sys/types.h>
60
60
#include <unistd.h>
69
69
        uds.insert( KIO::UDSEntry::UDS_MIME_TYPE, QString::fromLatin1( "inode/directory" ) );
70
70
        uds.insert( KIO::UDSEntry::UDS_ICON_OVERLAY_NAMES, QLatin1String( "nepomuk" ) );
71
71
        uds.insert( KIO::UDSEntry::UDS_DISPLAY_TYPE, i18n( "Query folder" ) );
72
 
        uds.insert( KIO::UDSEntry::UDS_NAME, Nepomuk::Query::Query::titleFromQueryUrl( url ) );
73
 
        uds.insert( KIO::UDSEntry::UDS_DISPLAY_NAME, Nepomuk::Query::Query::titleFromQueryUrl( url ) );
 
72
        uds.insert( KIO::UDSEntry::UDS_NAME, Nepomuk2::Query::Query::titleFromQueryUrl( url ) );
 
73
        uds.insert( KIO::UDSEntry::UDS_DISPLAY_NAME, Nepomuk2::Query::Query::titleFromQueryUrl( url ) );
74
74
        if ( url.hasQueryItem( QLatin1String( "resource" ) ) ) {
75
 
            Nepomuk::addGenericNepomukResourceData( Nepomuk::Resource( KUrl( url.queryItemValue( QLatin1String( "resource" ) ) ) ), uds );
 
75
            Nepomuk2::addGenericNepomukResourceData( Nepomuk2::Resource( KUrl( url.queryItemValue( QLatin1String( "resource" ) ) ) ), uds );
76
76
        }
77
 
        Nepomuk::Query::Query query = Nepomuk::Query::Query::fromQueryUrl( url );
 
77
        Nepomuk2::Query::Query query = Nepomuk2::Query::Query::fromQueryUrl( url );
78
78
        if ( query.isValid() )
79
79
            uds.insert( KIO::UDSEntry::UDS_NEPOMUK_QUERY, query.toString() );
80
80
        return uds;
102
102
    }
103
103
 
104
104
    KUrl convertLegacyQueryUrl( const KUrl& url ) {
105
 
        KUrl newUrl(QLatin1String("nepomuksearch:/") + Nepomuk::Query::Query::titleFromQueryUrl(url));
106
 
        Nepomuk::Query::Query query = Nepomuk::Query::Query::fromQueryUrl(url);
 
105
        KUrl newUrl(QLatin1String("nepomuksearch:/") + Nepomuk2::Query::Query::titleFromQueryUrl(url));
 
106
        Nepomuk2::Query::Query query = Nepomuk2::Query::Query::fromQueryUrl(url);
107
107
        if(query.isValid())
108
108
            newUrl.addQueryItem(QLatin1String("encodedquery"), query.toString());
109
109
        else
110
 
            newUrl.addQueryItem(QLatin1String("sparql"), Nepomuk::Query::Query::sparqlFromQueryUrl(url));
 
110
            newUrl.addQueryItem(QLatin1String("sparql"), Nepomuk2::Query::Query::sparqlFromQueryUrl(url));
111
111
        return newUrl;
112
112
    }
113
113
 
114
 
    Nepomuk::Query::Query rootQuery() {
 
114
    Nepomuk2::Query::Query rootQuery() {
115
115
        KConfig config( "kio_nepomuksearchrc" );
116
116
        QString queryStr = config.group( "General" ).readEntry( "Root query", QString() );
117
 
        Nepomuk::Query::Query query;
 
117
        Nepomuk2::Query::Query query;
118
118
        if ( queryStr.isEmpty() )
119
 
            query = Nepomuk::lastModifiedFilesQuery();
 
119
            query = Nepomuk2::lastModifiedFilesQuery();
120
120
        else
121
 
            query = Nepomuk::Query::Query::fromString( queryStr );
 
121
            query = Nepomuk2::Query::Query::fromString( queryStr );
122
122
        query.setLimit( config.group( "General" ).readEntry( "Root query limit", 10 ) );
123
123
        return query;
124
124
    }
126
126
}
127
127
 
128
128
 
129
 
Nepomuk::SearchProtocol::SearchProtocol( const QByteArray& poolSocket, const QByteArray& appSocket )
 
129
Nepomuk2::SearchProtocol::SearchProtocol( const QByteArray& poolSocket, const QByteArray& appSocket )
130
130
    : KIO::ForwardingSlaveBase( "nepomuksearch", poolSocket, appSocket )
131
131
{
132
132
}
133
133
 
134
134
 
135
 
Nepomuk::SearchProtocol::~SearchProtocol()
 
135
Nepomuk2::SearchProtocol::~SearchProtocol()
136
136
{
137
137
}
138
138
 
139
139
 
140
 
bool Nepomuk::SearchProtocol::ensureNepomukRunning( bool emitError )
 
140
bool Nepomuk2::SearchProtocol::ensureNepomukRunning( bool emitError )
141
141
{
142
 
    if ( Nepomuk::ResourceManager::instance()->init() ) {
 
142
    if ( Nepomuk2::ResourceManager::instance()->init() ) {
143
143
        kDebug() << "Failed to init Nepomuk";
144
144
        if ( emitError )
145
145
            error( KIO::ERR_SLAVE_DEFINED, i18n( "The desktop search service is not activated. Unable to answer queries without it." ) );
146
146
        return false;
147
147
    }
148
 
    else if ( !Nepomuk::Query::QueryServiceClient::serviceAvailable() ) {
 
148
    else if ( !Nepomuk2::Query::QueryServiceClient::serviceAvailable() ) {
149
149
        kDebug() << "Nepomuk Query service is not running.";
150
150
        if ( emitError )
151
151
            error( KIO::ERR_SLAVE_DEFINED, i18n( "The desktop search query service is not running. Unable to answer queries without it." ) );
157
157
}
158
158
 
159
159
 
160
 
void Nepomuk::SearchProtocol::listDir( const KUrl& url )
 
160
void Nepomuk2::SearchProtocol::listDir( const KUrl& url )
161
161
{
162
162
    kDebug() << url;
163
163
 
197
197
}
198
198
 
199
199
 
200
 
void Nepomuk::SearchProtocol::get( const KUrl& url )
 
200
void Nepomuk2::SearchProtocol::get( const KUrl& url )
201
201
{
202
202
    kDebug() << url;
203
203
 
208
208
}
209
209
 
210
210
 
211
 
void Nepomuk::SearchProtocol::put( const KUrl& url, int permissions, KIO::JobFlags flags )
 
211
void Nepomuk2::SearchProtocol::put( const KUrl& url, int permissions, KIO::JobFlags flags )
212
212
{
213
213
    kDebug() << url << permissions << flags;
214
214
 
220
220
}
221
221
 
222
222
 
223
 
void Nepomuk::SearchProtocol::mimetype( const KUrl& url )
 
223
void Nepomuk2::SearchProtocol::mimetype( const KUrl& url )
224
224
{
225
225
    kDebug() << url;
226
226
 
246
246
}
247
247
 
248
248
 
249
 
void Nepomuk::SearchProtocol::stat( const KUrl& url )
 
249
void Nepomuk2::SearchProtocol::stat( const KUrl& url )
250
250
{
251
251
    kDebug() << url;
252
252
 
283
283
}
284
284
 
285
285
 
286
 
void Nepomuk::SearchProtocol::del(const KUrl& url, bool isFile)
 
286
void Nepomuk2::SearchProtocol::del(const KUrl& url, bool isFile)
287
287
{
288
288
    ForwardingSlaveBase::del( url, isFile );
289
289
}
290
290
 
291
291
 
292
 
bool Nepomuk::SearchProtocol::rewriteUrl( const KUrl& url, KUrl& newURL )
 
292
bool Nepomuk2::SearchProtocol::rewriteUrl( const KUrl& url, KUrl& newURL )
293
293
{
294
294
    // we do it the speedy but slightly umpf way: decode the encoded URI from the filename
295
 
    newURL = Nepomuk::udsNameToResourceUri( url.fileName() );
 
295
    newURL = Nepomuk2::udsNameToResourceUri( url.fileName() );
296
296
    kDebug() << "URL:" << url << "NEW URL:" << newURL << newURL.protocol() << newURL.path() << newURL.fileName();
297
297
    return !newURL.isEmpty();
298
298
}
299
299
 
300
300
 
301
 
void Nepomuk::SearchProtocol::prepareUDSEntry( KIO::UDSEntry& uds, bool listing ) const
 
301
void Nepomuk2::SearchProtocol::prepareUDSEntry( KIO::UDSEntry& uds, bool listing ) const
302
302
{
303
303
    // do nothing - we do everything in SearchFolder::statResult
304
304
    Q_UNUSED(uds);
306
306
}
307
307
 
308
308
 
309
 
void Nepomuk::SearchProtocol::listRoot()
 
309
void Nepomuk2::SearchProtocol::listRoot()
310
310
{
311
311
    kDebug();
312
312
 
323
323
}
324
324
 
325
325
 
326
 
Nepomuk::SearchFolder* Nepomuk::SearchProtocol::getQueryFolder( const KUrl& url )
 
326
Nepomuk2::SearchFolder* Nepomuk2::SearchProtocol::getQueryFolder( const KUrl& url )
327
327
{
328
328
    return new SearchFolder( url, this );
329
329
}
330
330
 
331
331
 
332
 
void Nepomuk::SearchProtocol::updateQueryUrlHistory( const KUrl& url )
 
332
void Nepomuk2::SearchProtocol::updateQueryUrlHistory( const KUrl& url )
333
333
{
334
334
    //
335
335
    // if the url is already in the history update its timestamp
387
387
 
388
388
        kDebug(7102) << "Starting nepomuksearch slave " << getpid();
389
389
 
390
 
        Nepomuk::SearchProtocol slave( argv[2], argv[3] );
 
390
        Nepomuk2::SearchProtocol slave( argv[2], argv[3] );
391
391
        slave.dispatchLoop();
392
392
 
393
393
        kDebug(7102) << "Nepomuksearch slave Done";
398
398
 
399
399
 
400
400
#if 0
401
 
void Nepomuk::SearchProtocol::listUserQueries()
 
401
void Nepomuk2::SearchProtocol::listUserQueries()
402
402
{
403
403
    UserQueryUrlList userQueries;
404
404
    Q_FOREACH( const KUrl& url, userQueries ) {
407
407
        listEntry( uds, false );
408
408
    }
409
409
}
410
 
void Nepomuk::SearchProtocol::listLastQueries()
 
410
void Nepomuk2::SearchProtocol::listLastQueries()
411
411
{
412
412
    KSharedConfigPtr cfg = KSharedConfig::openConfig( "kio_nepomuksearchrc" );
413
413
    KConfigGroup grp = cfg->group( "Last Queries" );