« back to all changes in this revision
Viewing changes to src/utils.cpp
- browse files at revision 165
- compare with another revision
- download diff
- download tarball
- view history from revision 165
- Committer: Gary.Wzl
- Date: 2016-06-30 05:00:45 UTC
- mfrom: (163.1.12 4.8-local-hints)
- Revision ID: gary.wang@canonical.com-20160630050045-2p38uwpqgkdnge1x
Tags: 4.8
1.compile time optimization for string(QStringLiteral).
2.load the various json files once aggregator scope startup.
3.specify 'const' keyword for some variable in some cases.
4.pass by reference instead of by value if possible.
5.don't allocated memory(make_shared) based on local variable to avoid copy constructor.
6 remove duplicate obj creation.
7.fix invalid pointer for us::Category::SCPtr when look_up is called.
8.remove redundant files.
2.load the various json files once aggregator scope startup.
3.specify 'const' keyword for some variable in some cases.
4.pass by reference instead of by value if possible.
5.don't allocated memory(make_shared) based on local variable to avoid copy constructor.
6 remove duplicate obj creation.
7.fix invalid pointer for us::Category::SCPtr when look_up is called.
8.remove redundant files.
added
removed
src/utils.cpp
38
38
39
39
#define UNUSED(x) (void)(x);
40
40
41
QString locale_qs = QString::fromStdString(setlocale(LC_ALL, ""));
42
QString lang = locale_qs.left(2);
43
QString mid = locale_qs.left(5);
44
QString country = mid.right(2).toLower();
45
46
41
static constexpr const char *TRUE = "true";
47
42
static constexpr const char *FALSE = "false";
43
48
44
namespace
49
45
{
50
46
58
54
return QString::fromStdString(str);
59
55
}
60
56
61
static bool load_json_file(QJsonObject& root, std::string const & file_path, std::string const & scope_id)
62
{
63
std::ifstream f(file_path);
64
if (!f.good())
65
{
66
qWarning() << QString("%1. Can't find child json file path: %2").arg(
67
qstr(scope_id),
68
qstr(file_path));
69
return false;
70
}
71
72
std::stringstream buffer;
73
buffer << f.rdbuf();
74
std::string bytes = buffer.str();
75
76
QJsonDocument doc = QJsonDocument::fromJson(qstr(bytes).toUtf8());
77
78
if (!doc.isNull()) {
79
if (doc.isObject()) {
80
root = doc.object();
81
}
82
else
83
return false;
84
}
85
else
86
return false;
87
return true;
88
}
89
90
57
} // anonymous namespace
91
58
92
59
93
void Query::load_cardinality_settings()
60
void Query::load_cardinality_setting(QJsonObject const &root)
94
61
{
95
96
QString child_scopes_fn_qs = QString("%1/child_scopes.json").arg(qstr(scope_dir_));
97
98
QFile child_scopes_f;
99
child_scopes_f.setFileName(child_scopes_fn_qs);
100
child_scopes_f.open(QIODevice::ReadOnly);
101
QByteArray data = child_scopes_f.readAll();
102
103
QJsonParseError err;
104
QJsonDocument doc = QJsonDocument::fromJson(data, &err);
105
106
if (err.error != QJsonParseError::NoError)
107
{
108
qCritical() << "Failed to parse child_scopes.json data: " << err.errorString();
109
return;
110
}
111
112
QJsonObject doc_o = doc.object();
113
114
if (doc_o.contains("cardinality_settings"))
115
{
116
QJsonArray card_a = doc_o["cardinality_settings"].toArray();
117
for (auto item : card_a)
62
if (root.contains(QStringLiteral("cardinality_settings")))
63
{
64
QJsonArray card_a = root[QStringLiteral("cardinality_settings")].toArray();
65
for (const auto & item : card_a)
118
66
{
119
67
QJsonObject item_o = item.toObject();
120
qDebug() << " ===== CARD. found declared value: " << item_o["value"].toInt();
121
setting_cardinalities.push_back(item_o["value"].toInt());
68
qDebug() << " ===== CARD. found declared value: " << item_o[QStringLiteral("value")].toInt();
69
setting_cardinalities.push_back(item_o[QStringLiteral("value")].toInt());
122
70
}
123
71
}
124
72
}
125
73
126
int Query::get_setting_cardinality()
74
int Query::get_cardinality_setting()
127
75
{
128
76
us::VariantMap settings_ = settings();
129
77
auto it = settings_.find("cardinality");
138
86
/*
139
87
* Load declarations from child_scopes.json
140
88
*/
141
void Query::load_declarations()
89
void Query::load_declarations(QJsonObject const &root)
142
90
{
143
144
QString child_scopes_fn_qs = QString("%1/child_scopes.json").arg(qstr(scope_dir_));
145
146
QFile child_scopes_f;
147
child_scopes_f.setFileName(child_scopes_fn_qs);
148
child_scopes_f.open(QIODevice::ReadOnly);
149
QByteArray data = child_scopes_f.readAll();
150
151
QJsonParseError err;
152
QJsonDocument doc = QJsonDocument::fromJson(data, &err);
153
154
if (err.error != QJsonParseError::NoError)
155
{
156
qCritical() << "Failed to parse child_scopes.json data: " << err.errorString();
157
return;
158
}
159
160
QJsonObject doc_o = doc.object();
161
162
QJsonArray common_templates_a = doc_o["common_templates"].toArray();
163
164
for (const auto item_ : common_templates_a)
91
QJsonArray common_templates_a = root[QStringLiteral("common_templates")].toArray();
92
93
for (const auto & item_ : common_templates_a)
165
94
{
166
95
QJsonObject template_o = item_.toObject();
167
std::string id = template_o["id"].toString().toStdString();
96
std::string id = template_o[QStringLiteral("id")].toString().toStdString();
168
97
169
QJsonObject template__ = template_o["template"].toObject();
98
QJsonObject template__ = template_o[QStringLiteral("template")].toObject();
170
99
QJsonDocument t_d(template__);
171
std::string template_ = ::sstr(t_d.toJson());
172
173
common_templates[id] = template_;
174
if (template_o.contains("fallbacks"))
100
common_templates[id] = ::sstr(t_d.toJson());
101
if (template_o.contains(QStringLiteral("fallbacks")))
175
102
{
176
103
qDebug() << "==== FALLBACK in fallbacks, id: " << qstr(id);
177
QJsonArray fallbacks_a = template_o["fallbacks"].toArray();
178
std::map<std::string,std::vector<std::string>> fallbacks_m;
104
QJsonArray fallbacks_a = template_o[QStringLiteral("fallbacks")].toArray();
105
auto fallbacks_m = std::make_shared<std::map<std::string,std::vector<std::string>>>();
179
106
std::vector<std::string> fields;
180
for (const auto fb_ : fallbacks_a)
107
for (const auto & fb_ : fallbacks_a)
181
108
{
182
109
QJsonObject fb_o = fb_.toObject();
183
std::string key = fb_o["key"].toString().toStdString();
110
std::string key = fb_o[QStringLiteral("key")].toString().toStdString();
184
111
qDebug() << "==== FALLBACK key: " <<qstr(key);
185
QJsonArray fields_a = fb_o["fields"].toArray();
186
for (const auto f_ : fields_a)
112
QJsonArray fields_a = fb_o[QStringLiteral("fields")].toArray();
113
for (const auto & f_ : fields_a)
187
114
{
188
115
QJsonObject f_o = f_.toObject();
189
std::string field= f_o["field"].toString().toStdString();
116
std::string field= f_o[QStringLiteral("field")].toString().toStdString();
190
117
qDebug() << "==== FALLBACK field: " <<qstr(field);
191
118
fields.emplace_back(field);
192
119
}
193
fallbacks_m[key] = fields;
120
(*fallbacks_m)[key] = fields;
194
121
}
195
std::shared_ptr<std::map<std::string,std::vector<std::string>>> fbs = std::make_shared<std::map<std::string,std::vector<std::string>>>(fallbacks_m);
196
common_templates_fallbacks[id] = fbs;
122
123
common_templates_fallbacks[id] = fallbacks_m;
197
124
qDebug() << "==== load FALLB size 1: " << common_templates_fallbacks.size();
198
for (auto t : common_templates_fallbacks)
125
for (const auto & t : common_templates_fallbacks)
199
126
{
200
127
qDebug() << "==== load FALLB template id : " << qstr(t.first);
201
128
auto m_ptr = t.second;
202
for (auto &v : *m_ptr)
129
for (const auto & v : *m_ptr)
203
130
{
204
131
qDebug() << "==== load FALLB c_t_f result component " << qstr(v.first);
205
for (auto f : v.second)
132
for (const auto & f : v.second)
206
133
{
207
134
qDebug() << "==== load FALLB c_t_f result fallback " << qstr(f);
208
135
}
211
138
}
212
139
}
213
140
}
214
QJsonObject departments_o = doc_o["departments"].toObject();
215
if (doc_o.contains("departments"))
141
if (root.contains(QStringLiteral("departments")))
216
142
{
217
QJsonObject departments_o = doc_o["departments"].toObject();
143
QJsonObject departments_o = root[QStringLiteral("departments")].toObject();
218
144
219
145
bool use_depts = false;
220
if (departments_o.contains("do_not_use_departments"))
146
if (departments_o.contains(QStringLiteral("do_not_use_departments")))
221
147
{
222
if (departments_o["do_not_use_departments"].toString() != "true")
148
if (departments_o[QStringLiteral("do_not_use_departments")].toString() != "true")
223
149
{
224
150
using_departments = true;
225
151
use_depts = true;
231
157
}
232
158
if (use_depts)
233
159
{
234
QJsonArray declarations_a = departments_o["declarations"].toArray();
235
for (const auto item_ : declarations_a)
160
QJsonArray declarations_a = departments_o[QStringLiteral("declarations")].toArray();
161
for (const auto & item_ : declarations_a)
236
162
{
237
dept d_;
238
std::shared_ptr<dept> dept_ = std::make_shared<dept>(d_);
163
auto dept_ptr = std::make_shared<dept>();
239
164
QJsonObject dept_o = item_.toObject();
240
dept_->id = dept_o["id"].toString().toStdString();
241
dept_->title = _(dept_o["_title"].toString().toStdString().c_str());
242
if (dept_o.contains("root"))
165
dept_ptr->id = dept_o[QStringLiteral("id")].toString().toStdString();
166
dept_ptr->title = _(dept_o[QStringLiteral("_title")].toString().toStdString().c_str());
167
if (dept_o.contains(QStringLiteral("root")))
243
168
{
244
if (dept_o["root"].toString() == "true")
169
if (dept_o[QStringLiteral("root")].toString() == TRUE)
245
170
{
246
dept_->root = true;
247
dept_id_of_root = dept_->id;
171
dept_ptr->root = true;
172
dept_id_of_root = dept_ptr->id;
248
173
}
249
174
}
250
depts[dept_->id] = dept_;
175
depts[dept_ptr->id] = dept_ptr;
251
176
}
252
177
}
253
178
}
254
QJsonArray order_a = doc_o["order"].toArray();
179
QJsonArray order_a = root[QStringLiteral("order")].toArray();
255
180
256
for (const auto item_o_ : order_a)
181
for (const auto & item_o_ : order_a)
257
182
{
258
183
QJsonObject item_o = item_o_.toObject();
259
184
260
if (item_o.contains("category"))
185
if (item_o.contains(QStringLiteral("category")))
261
186
{
262
QJsonObject cat_o = item_o["category"].toObject();
263
category cat_;
264
std::shared_ptr<category> cat = std::make_shared<category>(cat_);
265
cat->id = cat_o["id"].toString().toStdString();
266
267
cat->title = cat_o["_title"].toString().toStdString();
268
cat->dept_id = cat_o["department"].toString().toStdString();
269
270
categoryId_titleMsgid[cat->id] = cat->title;
271
categoryIds.emplace_back(cat->id);
272
273
if (cat_o.contains("link_to_child_specified"))
187
QJsonObject cat_o = item_o[QStringLiteral("category")].toObject();
188
std::shared_ptr<category> cat_ptr = std::make_shared<category>();
189
cat_ptr->id = cat_o[QStringLiteral("id")].toString().toStdString();
190
191
cat_ptr->title = cat_o[QStringLiteral("_title")].toString().toStdString();
192
cat_ptr->dept_id = cat_o[QStringLiteral("department")].toString().toStdString();
193
194
categoryId_titleMsgid[cat_ptr->id] = cat_ptr->title;
195
categoryIds.emplace_back(cat_ptr->id);
196
197
if (cat_o.contains(QStringLiteral("link_to_child_specified")))
274
198
{
275
categoryId_linkToChildSpecified[cat->id] = cat_o["link_to_child_specified"].toString().toStdString();
199
categoryId_linkToChildSpecified[cat_ptr->id] = cat_o[QStringLiteral("link_to_child_specified")].toString().toStdString();
276
200
}
277
int card = get_setting_cardinality();
201
int card = get_cardinality_setting();
278
202
if (card > 0)
279
203
{
280
cat->cardinality = card;
204
cat_ptr->cardinality = card;
281
205
}
282
206
// but let declaration for category override user settings
283
if (cat_o.contains("cardinality"))
207
if (cat_o.contains(QStringLiteral("cardinality")))
284
208
{
285
int cardinality_ = cat_o["cardinality"].toInt();
286
if (cardinality_ > -1 )
209
int cardinality_ = cat_o[QStringLiteral("cardinality")].toInt();
210
if (cardinality_ > -1)
287
211
{
288
cat->cardinality = cardinality_;
212
cat_ptr->cardinality = cardinality_;
289
213
}
290
214
}
291
qDebug() << "=== CAT UTILs. id: " << qstr(cat->id) << " cardinality: " << QString::number(cat->cardinality);
215
qDebug() << "=== CAT UTILs. id: " << qstr(cat_ptr->id) << " cardinality: " << QString::number(cat_ptr->cardinality);
292
216
293
if (cat_o.contains("first_result_renderer_common_id"))
217
if (cat_o.contains(QStringLiteral("first_result_renderer_common_id")))
294
218
{
295
std::string id = cat_o["first_result_renderer_common_id"].toString().toStdString();
296
categoryId_first_result_renderers[cat->id] = common_templates[id];
297
categoryId_firstRdrs_catId2commonId[cat->id] = id;
219
std::string id = cat_o[QStringLiteral("first_result_renderer_common_id")].toString().toStdString();
220
categoryId_first_result_renderers[cat_ptr->id] = common_templates[id];
221
categoryId_firstRdrs_catId2commonId[cat_ptr->id] = id;
298
222
}
299
else if (cat_o.contains("first_result_renderer"))
223
else if (cat_o.contains(QStringLiteral("first_result_renderer")))
300
224
{
301
QJsonObject template_o = cat_o["first_result_renderer"].toObject();
225
QJsonObject template_o = cat_o[QStringLiteral("first_result_renderer")].toObject();
302
226
QJsonDocument t_d(template_o);
303
categoryId_first_result_renderers[cat->id] = sstr(t_d.toJson());
227
categoryId_first_result_renderers[cat_ptr->id] = sstr(t_d.toJson());
304
228
}
305
else if (cat_o.contains("first_result_template"))
229
else if (cat_o.contains(QStringLiteral("first_result_template")))
306
230
{
307
231
//support deprecated for backwards compatibiliity
308
qWarning () << QString("%1: DEPRECATED use of 'first_result_template'. Switch to 'first_result_renderer'").arg(qstr(scope_id));
309
QJsonObject template_o = cat_o["first_result_template"].toObject();
232
qWarning () << QString("%1: DEPRECATED use of 'first_result_template'. Switch to 'first_result_renderer'")
233
.arg(qstr(agg_scope_->scope_id()));
234
QJsonObject template_o = cat_o[QStringLiteral("first_result_template")].toObject();
310
235
QJsonDocument t_d(template_o);
311
categoryId_first_result_renderers[cat->id] = sstr(t_d.toJson());
236
categoryId_first_result_renderers[cat_ptr->id] = sstr(t_d.toJson());
312
237
}
313
238
314
if (cat_o.contains("renderer_common_id"))
239
if (cat_o.contains(QStringLiteral("renderer_common_id")))
315
240
{
316
std::string id = cat_o["renderer_common_id"].toString().toStdString();
317
cat->renderer = common_templates[id];
318
categoryId_surfaceRdrs_catId2commonId[cat->id] = id;
241
std::string id = cat_o[QStringLiteral("renderer_common_id")].toString().toStdString();
242
cat_ptr->renderer = common_templates[id];
243
categoryId_surfaceRdrs_catId2commonId[cat_ptr->id] = id;
319
244
}
320
else if (cat_o.contains("renderer"))
245
else if (cat_o.contains(QStringLiteral("renderer")))
321
246
{
322
QJsonObject renderer_o = cat_o["renderer"].toObject();
247
QJsonObject renderer_o = cat_o[QStringLiteral("renderer")].toObject();
323
248
QJsonDocument st_d(renderer_o);
324
cat->renderer = sstr(st_d.toJson());
249
cat_ptr->renderer = sstr(st_d.toJson());
325
250
}
326
251
327
if (cat_o.contains("search_renderer_common_id"))
252
if (cat_o.contains(QStringLiteral("search_renderer_common_id")))
328
253
{
329
254
qDebug() << "==== UTILs. load. CATRES. search_renderer_common_id";
330
std::string id = cat_o["search_renderer_common_id"].toString().toStdString();
331
cat->search_renderer = common_templates[id];
255
std::string id = cat_o[QStringLiteral("search_renderer_common_id")].toString().toStdString();
256
cat_ptr->search_renderer = common_templates[id];
332
257
}
333
else if (cat_o.contains("search_renderer"))
258
else if (cat_o.contains(QStringLiteral("search_renderer")))
334
259
{
335
260
qDebug() << "==== UTILs. load. CATRES. search_renderer";
336
QJsonObject renderer_o = cat_o["search_renderer"].toObject();
261
QJsonObject renderer_o = cat_o[QStringLiteral("search_renderer")].toObject();
337
262
QJsonDocument st_d(renderer_o);
338
cat->search_renderer = sstr(st_d.toJson());
263
cat_ptr->search_renderer = sstr(st_d.toJson());
339
264
}
340
265
341
if (cat_o.contains("scopes"))
266
if (cat_o.contains(QStringLiteral("scopes")))
342
267
{
343
QJsonArray scope_a = cat_o["scopes"].toArray();
268
QJsonArray scope_a = cat_o[QStringLiteral("scopes")].toArray();
344
269
345
270
for (const auto item : scope_a)
346
271
{
347
272
QJsonObject scope_o = item.toObject();
348
std::string id = scope_o["id"].toString().toStdString();
349
std::string local_id = scope_o["local_id"].toString().toStdString();
273
std::string id = scope_o[QStringLiteral("id")].toString().toStdString();
274
std::string local_id = scope_o[QStringLiteral("local_id")].toString().toStdString();
350
275
351
276
//TODO doc that a child_department may include LANGCODE for replacement
352
277
//from locale lang code, and COUNTRYCODE with locale country code
353
if (scope_o.contains("child_department"))
278
if (scope_o.contains(QStringLiteral("child_department")))
354
279
{
355
QString child_dept = scope_o["child_department"].toString();
356
if (lang.size() == 2)
357
{
358
if (child_dept.contains("LANGCODE"))
359
child_dept = child_dept.replace("LANGCODE", lang);
360
scopeLocalId_childDept_m[local_id] = child_dept.toStdString();
361
}
362
if (country.size() == 2)
363
{
280
QString child_dept = scope_o[QStringLiteral("child_department")].toString();
364
281
365
if (child_dept.contains("COUNTRYCODE"))
366
child_dept = child_dept.replace("COUNTRYCODE", country);
367
scopeLocalId_childDept_m[local_id] = child_dept.toStdString();
368
}
369
qDebug() << qstr("=== CHDEPT. lang: %1 local %2. dept %3").arg(lang, qstr(local_id), qstr(scopeLocalId_childDept_m[local_id]));
282
if (agg_scope_->lang().size() == 2 && child_dept.contains(QStringLiteral("LANGCODE")))
283
{
284
child_dept = child_dept.replace(QStringLiteral("LANGCODE"), qstr(agg_scope_->lang()));
285
scopeLocalId_childDept_m[local_id] = child_dept.toStdString();
286
}
287
if (agg_scope_->country().size() == 2 && child_dept.contains(QStringLiteral("COUNTRYCODE")))
288
{
289
child_dept = child_dept.replace(QStringLiteral("COUNTRYCODE"), qstr(agg_scope_->country()));
290
scopeLocalId_childDept_m[local_id] = child_dept.toStdString();
291
}
292
qDebug() << qstr("=== CHDEPT. lang: %1 local %2. dept %3").arg(qstr(agg_scope_->lang()),
293
qstr(local_id), qstr(scopeLocalId_childDept_m[local_id]));
370
294
}
371
if (scope_o.contains("default_query_string"))
295
if (scope_o.contains(QStringLiteral("default_query_string")))
372
296
{
373
297
374
std::string default_qry_str = scope_o["default_query_string"].toString().toStdString();
298
std::string default_qry_str = scope_o[QStringLiteral("default_query_string")].toString().toStdString();
375
299
localId_defaultQryStr[local_id] = default_qry_str;
376
300
}
377
301
378
cat->scopes.emplace_back(std::pair<std::string,std::string>(id,local_id));
302
cat_ptr->scopes.emplace_back(std::pair<std::string,std::string>(id,local_id));
379
303
}
380
304
}
381
if (cat_o.contains("keywords"))
305
if (cat_o.contains(QStringLiteral("keywords")))
382
306
{
383
QJsonArray keyword_a = cat_o["keywords"].toArray();
307
QJsonArray keyword_a = cat_o[QStringLiteral("keywords")].toArray();
384
308
385
for (const auto item : keyword_a)
309
for (const auto & item : keyword_a)
386
310
{
387
311
QJsonObject keyword_o = item.toObject();
388
std::string id = keyword_o["id"].toString().toStdString();
389
std::string local_id = keyword_o["local_id"].toString().toStdString();
390
cat->keywords.emplace_back(id);
391
cat->keyword_ids.emplace_back(std::pair<std::string,std::string>(id,local_id));
312
std::string id = keyword_o[QStringLiteral("id")].toString().toStdString();
313
std::string local_id = keyword_o[QStringLiteral("local_id")].toString().toStdString();
314
cat_ptr->keywords.emplace_back(id);
315
cat_ptr->keyword_ids.emplace_back(std::pair<std::string,std::string>(id,local_id));
392
316
declared_category_keywords.emplace_back(id);
393
317
}
394
318
}
395
319
396
declared_order.emplace_back(cat->id);
397
categories.emplace_back(cat);
398
id_category_m[cat->id] = cat;
320
declared_order.emplace_back(cat_ptr->id);
321
categories.emplace_back(cat_ptr);
322
id_category_m[cat_ptr->id] = cat_ptr;
399
323
} // end "category"
400
324
401
if (item_o.contains("scope"))
325
if (item_o.contains(QStringLiteral("scope")))
402
326
{
403
QJsonObject scope_o = item_o["scope"].toObject();
404
child_scope cs_;
405
std::shared_ptr<child_scope> cs = std::make_shared<child_scope>(cs_);
406
407
cs->id = scope_o["id"].toString().toStdString();
408
cs->local_id = scope_o["local_id"].toString().toStdString();
327
QJsonObject scope_o = item_o[QStringLiteral("scope")].toObject();
328
std::shared_ptr<child_scope> cs = std::make_shared<child_scope>();
329
cs->id = scope_o[QStringLiteral("id")].toString().toStdString();
330
cs->local_id = scope_o[QStringLiteral("local_id")].toString().toStdString();
409
331
declared_order.emplace_back(cs->local_id);
410
332
411
if (scope_o.contains("department"))
412
cs->department = scope_o["department"].toString().toStdString();
333
if (scope_o.contains(QStringLiteral("department")))
334
cs->department = scope_o[QStringLiteral("department")].toString().toStdString();
413
335
414
if (scope_o.contains("link_to_child"))
336
cs->link_to_child = true;
337
if (scope_o.contains(QStringLiteral("link_to_child")))
415
338
{
416
if (scope_o["link_to_child"].toString() == "false")
339
if (scope_o[QStringLiteral("link_to_child")].toString() == FALSE)
417
340
cs->link_to_child = false;
418
341
}
419
else
420
{
421
cs->link_to_child = true;
422
}
423
424
if (scope_o.contains("source_finder"))
425
{
426
if (scope_o["source_finder"].toString() == "true") {
427
cs->source_finder = true;
428
}
429
}
430
431
if (scope_o.contains("category_title_use_incoming"))
342
343
cs->source_finder = false;
344
if (scope_o.contains(QStringLiteral("source_finder"))
345
&& scope_o[QStringLiteral("source_finder")].toString() == TRUE) {
346
cs->source_finder = true;
347
}
348
349
if (scope_o.contains(QStringLiteral("category_title_use_incoming")))
432
350
{
433
351
cs->using_category_title_incoming = true;
434
352
}
435
else if (scope_o.contains("category_title_use_display_name"))
353
else if (scope_o.contains(QStringLiteral("category_title_use_display_name")))
436
354
{
437
355
cs->using_category_title_display_name = true;
438
356
}
439
357
else
440
358
{
441
if (scope_o.contains("category_title"))
442
cs->category_title = scope_o["category_title"].toString().toStdString();
359
if (scope_o.contains(QStringLiteral("category_title")))
360
cs->category_title = scope_o[QStringLiteral("category_title")].toString().toStdString();
443
361
444
if (scope_o.contains("_category_title"))
445
cs->category_title_ = scope_o["_category_title"].toString().toStdString();
362
if (scope_o.contains(QStringLiteral("_category_title")))
363
cs->category_title_ = scope_o[QStringLiteral("_category_title")].toString().toStdString();
446
364
qDebug() << "==== TITLE_: " << qstr(cs->category_title);
447
365
qDebug() << "==== TITLE_: " << qstr(cs->category_title_);
448
366
}
449
367
450
368
//TODO doc that a child_department may include LANGCODE for replacement
451
369
//from locale lang code, and COUNTRYCODE with locale country code
452
if (scope_o.contains("child_department"))
370
if (scope_o.contains(QStringLiteral("child_department")))
453
371
{
454
QString child_dept = scope_o["child_department"].toString();
455
if (lang.size() == 2)
456
{
457
if (child_dept.contains("LANGCODE"))
458
child_dept = child_dept.replace("LANGCODE", lang);
459
}
460
if (country.size() == 2)
461
{
372
QString child_dept = scope_o[QStringLiteral("child_department")].toString();
462
373
463
if (child_dept.contains("COUNTRYCODE"))
464
child_dept = child_dept.replace("COUNTRYCODE", country);
374
if (agg_scope_->lang().size() == 2 && child_dept.contains("LANGCODE"))
375
{
376
child_dept = child_dept.replace("LANGCODE", qstr(agg_scope_->lang()));
377
}
378
if (agg_scope_->country().size() == 2 && child_dept.contains("COUNTRYCODE"))
379
{
380
child_dept = child_dept.replace("COUNTRYCODE", qstr(agg_scope_->country()));
465
381
}
466
382
cs->child_department = child_dept.toStdString();
467
383
}
468
384
469
if (scope_o.contains("child_category"))
470
cs->child_category = scope_o["child_category"].toString().toStdString();
471
472
if (scope_o.contains("child_category_max_results"))
473
{
474
cs->child_category_max_results = (int)scope_o["child_category_max_results"].toInt();
475
cs->using_child_category_max_results = true;
476
}
477
else if (scope_o.contains("child_category"))
478
cs->using_child_category_max_results = true;
479
480
int card = get_setting_cardinality();
385
if (scope_o.contains(QStringLiteral("child_category")))
386
cs->child_category = scope_o[QStringLiteral("child_category")].toString().toStdString();
387
388
if (scope_o.contains(QStringLiteral("child_category_max_results")))
389
{
390
cs->child_category_max_results = scope_o[QStringLiteral("child_category_max_results")].toInt();
391
cs->using_child_category_max_results = true;
392
}
393
else if (scope_o.contains(QStringLiteral("child_category")))
394
{
395
cs->using_child_category_max_results = true;
396
}
397
398
int card = get_cardinality_setting();
481
399
if (card > 0)
482
400
{
483
401
cs->cardinality = card;
484
402
}
485
403
// but let declaration for category override user settings
486
if (scope_o.contains("cardinality"))
404
if (scope_o.contains(QStringLiteral("cardinality")))
487
405
{
488
int cardinality_ = scope_o["cardinality"].toInt();
406
int cardinality_ = scope_o[QStringLiteral("cardinality")].toInt();
489
407
if (cardinality_ > -1)
490
408
{
491
409
cs->cardinality = cardinality_;
492
410
}
493
411
}
494
if (scope_o.contains("first_result_renderer_common_id"))
412
if (scope_o.contains(QStringLiteral("first_result_renderer_common_id")))
495
413
{
496
std::string id = scope_o["first_result_renderer_common_id"].toString().toStdString();
414
std::string id = scope_o[QStringLiteral("first_result_renderer_common_id")].toString().toStdString();
497
415
cs->first_result_template = common_templates[id];
498
416
}
499
else if (scope_o.contains("first_result_renderer"))
417
else if (scope_o.contains(QStringLiteral("first_result_renderer")))
500
418
{
501
QJsonObject template_o = scope_o["first_result_renderer"].toObject();
419
QJsonObject template_o = scope_o[QStringLiteral("first_result_renderer")].toObject();
502
420
QJsonDocument t_d(template_o);
503
421
cs->first_result_template = sstr(t_d.toJson());
504
422
}
505
else if (scope_o.contains("first_result_template"))
423
else if (scope_o.contains(QStringLiteral("first_result_template")))
506
424
{
507
425
//support deprecated for backwards compatibiliity
508
qWarning () << QString("%1: DEPRECATED use of 'first_result_template'. Switch to 'first_result_renderer'").arg(qstr(scope_id));
509
QJsonObject template_o = scope_o["first_result_template"].toObject();
426
qWarning () << QString("%1: DEPRECATED use of 'first_result_template'. Switch to 'first_result_renderer'").arg(qstr(agg_scope_->scope_id()));
427
QJsonObject template_o = scope_o[QStringLiteral("first_result_template")].toObject();
510
428
QJsonDocument t_d(template_o);
511
429
cs->first_result_template = sstr(t_d.toJson());
512
430
}
513
431
514
if (scope_o.contains("renderer_common_id"))
432
if (scope_o.contains(QStringLiteral("renderer_common_id")))
515
433
{
516
std::string id = scope_o["renderer_common_id"].toString().toStdString();
434
std::string id = scope_o[QStringLiteral("renderer_common_id")].toString().toStdString();
517
435
cs->surface_template = common_templates[id];
518
436
cs->overriding_surface_template = true;
519
437
}
520
else if (scope_o.contains("renderer"))
438
else if (scope_o.contains(QStringLiteral("renderer")))
521
439
{
522
QJsonObject surface_template_o = scope_o["renderer"].toObject();
440
QJsonObject surface_template_o = scope_o[QStringLiteral("renderer")].toObject();
523
441
QJsonDocument st_d(surface_template_o);
524
442
cs->surface_template = sstr(st_d.toJson());
525
443
cs->overriding_surface_template = true;
526
444
}
527
else if (scope_o.contains("surface_template"))
445
else if (scope_o.contains(QStringLiteral("surface_template")))
528
446
{
529
447
//support deprecated for backwards compatibility
530
qWarning () << QString("%1: DEPRECATED use of 'surface_template'. Switch to 'surface_renderer'").arg(qstr(scope_id));
531
QJsonObject surface_template_o = scope_o["surface_template"].toObject();
448
qWarning () << QString("%1: DEPRECATED use of 'surface_template'. Switch to 'surface_renderer'").arg(qstr(agg_scope_->scope_id()));
449
QJsonObject surface_template_o = scope_o[QStringLiteral("surface_template")].toObject();
532
450
QJsonDocument st_d(surface_template_o);
533
451
cs->surface_template = sstr(st_d.toJson());
534
452
cs->overriding_surface_template = true;
535
453
}
536
454
537
if (scope_o.contains("search_renderer_common_id"))
455
if (scope_o.contains(QStringLiteral("search_renderer_common_id")))
538
456
{
539
457
qDebug() << "==== SEARCH red com fouund";
540
458
std::string id = scope_o["search_renderer_common_id"].toString().toStdString();
541
459
cs->search_template = common_templates[id];
542
460
cs->overriding_search_template = true;
543
461
}
544
else if (scope_o.contains("search_renderer"))
462
else if (scope_o.contains(QStringLiteral("search_renderer")))
545
463
{
546
QJsonObject search_template_o = scope_o["search_renderer"].toObject();
464
QJsonObject search_template_o = scope_o[QStringLiteral("search_renderer")].toObject();
547
465
QJsonDocument search_d(search_template_o);
548
466
cs->search_template = sstr(search_d.toJson());
549
467
cs->overriding_search_template = true;
550
468
}
551
else if (scope_o.contains("search_template"))
469
else if (scope_o.contains(QStringLiteral("search_template")))
552
470
{
553
471
//support deprecated for backwards compatibility
554
qWarning () << QString("%1: DEPRECATED use of 'search_template'. Switch to 'search_renderer'").arg(qstr(scope_id));
555
QJsonObject search_template_o = scope_o["search_template"].toObject();
472
qWarning () << QString("%1: DEPRECATED use of 'search_template'. Switch to 'search_renderer'").arg(qstr(agg_scope_->scope_id()));
473
QJsonObject search_template_o = scope_o[QStringLiteral("search_template")].toObject();
556
474
QJsonDocument search_d(search_template_o);
557
475
cs->search_template = sstr(search_d.toJson());
558
476
cs->overriding_search_template = true;
559
477
}
560
478
561
if (scope_o.contains("swap_result_attributes"))
479
if (scope_o.contains(QStringLiteral("swap_result_attributes")))
562
480
{
563
QJsonArray swaps_a = scope_o["swap_result_attributes"].toArray();
564
for (const auto swap_o_ : swaps_a)
481
QJsonArray swaps_a = scope_o[QStringLiteral("swap_result_attributes")].toArray();
482
for (const auto & swap_o_ : swaps_a)
565
483
{
566
484
QJsonObject swap_o = swap_o_.toObject();
567
std::pair<std::string,std::string> swap;
568
swap.first = swap_o["incoming_result_key"].toString().toStdString();
569
swap.second = swap_o["new_result_key"].toString().toStdString();
570
std::shared_ptr<std::pair<std::string,std::string>> swap_ = std::make_shared<std::pair<std::string,std::string>>(swap);
485
auto swap_ = std::make_shared<std::pair<std::string,std::string>>();
486
(*swap_).first = swap_o[QStringLiteral("incoming_result_key")].toString().toStdString();
487
(*swap_).second = swap_o[QStringLiteral("new_result_key")].toString().toStdString();
571
488
cs->swap_result_attributes.emplace_back(swap_);
572
489
}
573
574
490
}
575
491
576
if (scope_o.contains("result_category_id_to_common_template"))
492
if (scope_o.contains(QStringLiteral("result_category_id_to_common_template")))
577
493
{
578
QJsonArray items_a = scope_o["result_category_id_to_common_template"].toArray();
579
for (const auto item_o_ : items_a)
494
QJsonArray items_a = scope_o[QStringLiteral("result_category_id_to_common_template")].toArray();
495
for (const auto & item_o_ : items_a)
580
496
{
581
497
QJsonObject item_o = item_o_.toObject();
582
std::string res_cat_id = item_o["result_category_id"].toString().toStdString();
583
std::string common_template = item_o["common_template"].toString().toStdString();
498
std::string res_cat_id = item_o[QStringLiteral("result_category_id")].toString().toStdString();
499
std::string common_template = item_o[QStringLiteral("common_template")].toString().toStdString();
584
500
cs->result_category_id_to_common_template[res_cat_id] = common_template;
585
501
}
586
502
}
587
503
588
if (scope_o.contains("default_query_string"))
504
if (scope_o.contains(QStringLiteral("default_query_string")))
589
505
{
590
QString default_query_string = scope_o["default_query_string"].toString();
506
QString default_query_string = scope_o[QStringLiteral("default_query_string")].toString();
591
507
localId_defaultQryStr[cs->local_id] = default_query_string.toStdString();
592
508
}
593
509
594
if (scope_o.contains("only_in_search") && scope_o["only_in_search"] == "true")
510
if (scope_o.contains(QStringLiteral("only_in_search"))
511
&& scope_o[QStringLiteral("only_in_search")] == TRUE)
595
512
{
596
513
cs->only_in_search = true;
597
514
cs->overriding_search_template = true;
598
} else {
599
cs->only_in_search = false;
600
515
}
601
516
602
517
child_scopes.emplace_back(cs);
603
518
child_scopes_m[cs->local_id] = cs;
604
519
type_ids_m[cs->local_id].emplace_back(cs->local_id);
605
520
} // end "scope"
606
else if (item_o.contains("keyword"))
521
else if (item_o.contains(QStringLiteral("keyword")))
607
522
{
608
keyword keyword_;
609
QJsonObject keyword_o = item_o["keyword"].toObject();
610
std::string keyword_id = keyword_o["keyword"].toString().toStdString();
611
keyword_.id = keyword_id;
523
auto keyword_ = std::make_shared<keyword>();
524
QJsonObject keyword_o = item_o[QStringLiteral("keyword")].toObject();
525
std::string keyword_id = keyword_o[QStringLiteral("keyword")].toString().toStdString();
526
keyword_->id = keyword_id;
612
527
613
528
declared_keywords.emplace_back(keyword_id);
614
529
declared_order.emplace_back(keyword_id);
615
530
616
int card = get_setting_cardinality();
531
int card = get_cardinality_setting();
617
532
if (card > 0)
618
533
{
619
keyword_.cardinality = card;
534
keyword_->cardinality = card;
620
535
}
621
536
// but let declaration for category override user settings
622
if (keyword_o.contains("cardinality"))
537
if (keyword_o.contains(QStringLiteral("cardinality")))
623
538
{
624
int keyword_cardinality_ = keyword_o["cardinality"].toInt();
539
int keyword_cardinality_ = keyword_o[QStringLiteral("cardinality")].toInt();
625
540
if (keyword_cardinality_ > -1)
626
541
{
627
keyword_.cardinality = keyword_cardinality_;
542
keyword_->cardinality = keyword_cardinality_;
628
543
}
629
544
}
630
545
if (using_departments)
631
546
{
632
std::string dept_title_msgid = keyword_o["_department_title"].toString().toStdString();
547
std::string dept_title_msgid = keyword_o[QStringLiteral("_department_title")].toString().toStdString();
633
548
keyword_deptTitleMsgid[keyword_id] = dept_title_msgid;
634
if (keyword_o.contains("department"))
549
if (keyword_o.contains(QStringLiteral("department")))
635
550
{
636
637
std::string kwdept = keyword_o["department"].toString().toStdString();
551
std::string kwdept = keyword_o[QStringLiteral("department")].toString().toStdString();
638
552
keyword_deptId[keyword_id] = kwdept;
639
keyword_.dept_id = kwdept;
553
keyword_->dept_id = kwdept;
640
554
}
641
555
else if (dept_id_of_root_keywords_only.empty())
642
556
dept_id_of_root_keywords_only = keyword_id;
643
557
}
644
558
std::string category;
645
if (keyword_o.contains("shared_category"))
559
if (keyword_o.contains(QStringLiteral("shared_category")))
646
560
{
647
561
category = keyword_id; // note category is synomous with keyword and is therefore used even when not shared category
648
562
//note: removed support for shared_category value other than "true"
649
if (keyword_o["shared_category"] == "true")
563
if (keyword_o[QStringLiteral("shared_category")] == TRUE)
650
564
{
651
std::string title_msgid = keyword_o["_shared_category_title"].toString().toStdString();
565
std::string title_msgid = keyword_o[QStringLiteral("_shared_category_title")].toString().toStdString();
652
566
shared_keyword_cat_titlemsgid[category] = title_msgid;
653
567
shared_keyword_cats[keyword_id] = category;
654
568
shared_keywords.emplace_back(keyword_id);
655
569
}
656
570
}
657
571
//we do not support first result with non shared category keyword scopes
658
if (category == keyword_id && keyword_o.contains("first_result_renderer_common_id"))
572
if (category == keyword_id && keyword_o.contains(QStringLiteral("first_result_renderer_common_id")))
659
573
{
660
std::string id = keyword_o["first_result_renderer_common_id"].toString().toStdString();
574
std::string id = keyword_o[QStringLiteral("first_result_renderer_common_id")].toString().toStdString();
661
575
keyword_catname_first_result_renderers[category] = common_templates[id];
662
576
}
663
else if (category == keyword_id && keyword_o.contains("first_result_renderer"))
577
else if (category == keyword_id && keyword_o.contains(QStringLiteral("first_result_renderer")))
664
578
{
665
QJsonObject template_o = keyword_o["first_result_renderer"].toObject();
579
QJsonObject template_o = keyword_o[QStringLiteral("first_result_renderer")].toObject();
666
580
QJsonDocument t_d(template_o);
667
581
keyword_catname_first_result_renderers[category] = sstr(t_d.toJson());
668
582
}
669
else if (category == keyword_id && keyword_o.contains("first_result_template"))
583
else if (category == keyword_id && keyword_o.contains(QStringLiteral("first_result_template")))
670
584
{
671
585
//support deprecated for backwards compatibiliity
672
qWarning () << QString("%1: DEPRECATED use of 'first_result_template'. Switch to 'first_result_renderer'").arg(qstr(scope_id));
673
QJsonObject template_o = keyword_o["first_result_template"].toObject();
586
qWarning () << QString("%1: DEPRECATED use of 'first_result_template'. Switch to 'first_result_renderer'")
587
.arg(qstr(agg_scope_->scope_id()));
588
QJsonObject template_o = keyword_o[QStringLiteral("first_result_template")].toObject();
674
589
QJsonDocument t_d(template_o);
675
590
keyword_catname_first_result_renderers[category] = sstr(t_d.toJson());
676
591
}
679
594
//is the same as with a declared scope, which means "renderer_common_id", "renderer",
680
595
//"first_result_renderer_common_id", "first_result_renderer", "search_renderer_common_id",
681
596
//and "search_renderer"
682
if (keyword_o.contains("renderer_common_id"))
597
if (keyword_o.contains(QStringLiteral("renderer_common_id")))
683
598
{
684
599
qDebug() << "==== UTILs. load. KW CAT. renderer_common_id. keyword&category: " << qstr(category);;
685
std::string id = keyword_o["renderer_common_id"].toString().toStdString();
600
std::string id = keyword_o[QStringLiteral("renderer_common_id")].toString().toStdString();
686
601
keyword_catname_renderer[category] = common_templates[id];
687
602
688
603
qDebug() << "==== UTILs. load. KW CAT. renderer_common_id: "<< qstr(keyword_catname_renderer[category]).replace("\n", " ");
689
604
}
690
else if (keyword_o.contains("renderer"))
605
else if (keyword_o.contains(QStringLiteral("renderer")))
691
606
{
692
607
qDebug() << "==== UTILs. load. KW CAT. renderer";
693
QJsonObject renderer_o = keyword_o["renderer"].toObject();
608
QJsonObject renderer_o = keyword_o[QStringLiteral("renderer")].toObject();
694
609
QJsonDocument rdr_d(renderer_o);
695
610
keyword_catname_renderer[category] = sstr(rdr_d.toJson());
696
611
697
612
qDebug() << "==== UTILs. load. KW CAT. renderer:" << qstr(keyword_catname_renderer[category]).replace("\n", " ");
698
613
}
699
else if (keyword_o.contains("category_renderer_common_id"))
614
else if (keyword_o.contains(QStringLiteral("category_renderer_common_id")))
700
615
{
701
616
qDebug() << "==== UTILs. load. KW SHARED CAT. category_renderer_common_id";
702
std::string id = keyword_o["category_renderer_common_id"].toString().toStdString();
617
std::string id = keyword_o[QStringLiteral("category_renderer_common_id")].toString().toStdString();
703
618
keyword_catname_renderer[category] = common_templates[id];
704
619
}
705
else if (keyword_o.contains("category_renderer"))
620
else if (keyword_o.contains(QStringLiteral("category_renderer")))
706
621
{
707
622
qDebug() << "==== UTILs. load. KW CAT. category_renderer";
708
QJsonObject renderer_o = keyword_o["category_renderer"].toObject();
623
QJsonObject renderer_o = keyword_o[QStringLiteral("category_renderer")].toObject();
709
624
QJsonDocument rdr_d(renderer_o);
710
625
keyword_catname_renderer[category] = sstr(rdr_d.toJson());
711
626
}
712
if (keyword_o.contains("search_renderer_common_id"))
627
if (keyword_o.contains(QStringLiteral("search_renderer_common_id")))
713
628
{
714
std::string id = keyword_o["search_renderer_common_id"].toString().toStdString();
629
std::string id = keyword_o[QStringLiteral("search_renderer_common_id")].toString().toStdString();
715
630
keyword_catname_search_renderer[category] = common_templates[id];
716
631
}
717
else if (keyword_o.contains("search_renderer"))
632
else if (keyword_o.contains(QStringLiteral("search_renderer")))
718
633
{
719
QJsonObject renderer_o = keyword_o["search_renderer"].toObject();
634
QJsonObject renderer_o = keyword_o[QStringLiteral("search_renderer")].toObject();
720
635
QJsonDocument rdr_d(renderer_o);
721
636
keyword_catname_search_renderer[category] = sstr(rdr_d.toJson());
722
637
}
723
if (keyword_o.contains("link_to_child"))
724
{
725
if (keyword_o["link_to_child"].toString() == "true")
726
keyword_.link_to_child = true;
727
}
728
if (keyword_o.contains("exclude_scopes"))
729
{
730
QJsonArray scope_a = keyword_o["exclude_scopes"].toArray();
731
732
for (const auto item : scope_a)
733
{
734
QJsonObject scope_o = item.toObject();
735
std::string id = scope_o["id"].toString().toStdString();
736
keyword_.exclude_scopes.emplace_back(id);
737
}
738
}
739
if (keyword_o.contains("display_order"))
740
{
741
QJsonArray scope_a = keyword_o["display_order"].toArray();
742
743
for (const auto item : scope_a)
744
{
745
QJsonObject scope_o = item.toObject();
746
std::string id = scope_o["id"].toString().toStdString();
747
keyword_.display_order.emplace_back(id);
748
}
749
}
750
751
std::shared_ptr<keyword> kw_ptr = std::make_shared<keyword>(keyword_);
752
keywords.emplace_back(kw_ptr);
753
id_keyword_map[keyword_id] = kw_ptr;
638
if (keyword_o.contains(QStringLiteral("link_to_child"))
639
&& keyword_o[QStringLiteral("link_to_child")].toString() == TRUE) {
640
keyword_->link_to_child = true;
641
}
642
if (keyword_o.contains(QStringLiteral("exclude_scopes")))
643
{
644
QJsonArray scope_a = keyword_o[QStringLiteral("exclude_scopes")].toArray();
645
646
for (const auto & item : scope_a)
647
{
648
QJsonObject scope_o = item.toObject();
649
std::string id = scope_o[QStringLiteral("id")].toString().toStdString();
650
keyword_->exclude_scopes.emplace_back(id);
651
}
652
}
653
if (keyword_o.contains(QStringLiteral("display_order")))
654
{
655
QJsonArray scope_a = keyword_o[QStringLiteral("display_order")].toArray();
656
657
for (const auto & item : scope_a)
658
{
659
QJsonObject scope_o = item.toObject();
660
std::string id = scope_o[QStringLiteral("id")].toString().toStdString();
661
keyword_->display_order.emplace_back(id);
662
}
663
}
664
665
keywords.emplace_back(keyword_);
666
id_keyword_map[keyword_id] = keyword_;
754
667
}
755
668
}
756
669
//for (auto str : declared_order)
762
675
for (std::string id : declared_order)
763
676
{
764
677
//qDebug() << "==== SET ORDER. DECLARED order id: " << qstr(id);
765
for (auto pr : type_ids_m)
678
for (const auto & pr : type_ids_m)
766
679
{
767
680
if (pr.first == id)
768
681
{
769
682
bool foundKeyword = false;
770
for (auto kwv : keywords)
683
for (const auto & kwv : keywords)
771
684
{
772
685
if (id == kwv->id)
773
686
{
777
690
std::vector<std::string>::iterator orderIter;
778
691
std::vector<std::string> order_keyscopes;
779
692
std::vector<std::string> unorder_keyscopes;
780
for (std::string scope_id : pr.second)
693
for (const auto & scope_id : pr.second)
781
694
{
782
695
bool foundScope = false;
783
696
for (int i = 0; i < (int)kwv->display_order.size() ; i++)
822
735
823
736
if (!foundKeyword)
824
737
{
825
for (auto id_ : pr.second)
738
for (const auto & id_ : pr.second)
826
739
{
827
740
scopes_ordered.emplace_back(id_);
828
741
qDebug() << "==== SET ORDER DECLARED adding to scopes_ordered id: " << qstr(id_);
831
744
}
832
745
}
833
746
}
834
for(auto sc : scopes_ordered) {
747
for(const auto & sc : scopes_ordered) {
835
748
qDebug() << "==== FINAL ORDER: " << qstr(sc);
836
749
}
837
750
}
846
759
//iterate declared child scopes
847
760
for (std::shared_ptr<child_scope> child : child_scopes)
848
761
{
849
AggChildScope ch(child->id);
850
851
ch.set_local_id(child->local_id);
762
auto ch_ptr = std::make_shared<AggChildScope>(child->id);
763
ch_ptr->set_local_id(child->local_id);
852
764
853
765
localId_id_m[child->local_id] = child->id;
854
766
855
767
if (child->using_category_title_incoming)
856
768
{
857
ch.set_category_title_incoming(true);
769
ch_ptr->set_category_title_incoming(true);
858
770
}
859
771
else if (child->using_category_title_display_name)
860
772
{
861
ch.set_category_title_display_name(true);
773
ch_ptr->set_category_title_display_name(true);
862
774
}
863
775
else
864
776
{
865
777
if (child->category_title_ != "")
866
778
{
867
ch.set_category_title(_(child->category_title_.c_str()));
779
ch_ptr->set_category_title(_(child->category_title_.c_str()));
868
780
}
869
781
else
870
ch.set_category_title(child->category_title);
782
ch_ptr->set_category_title(child->category_title);
871
783
}
872
784
873
785
if (child->child_department != "")
874
ch.set_child_department(child->child_department);
786
ch_ptr->set_child_department(child->child_department);
875
787
876
788
if (child->department != "")
877
ch.set_department(child->department);
789
ch_ptr->set_department(child->department);
878
790
879
ch.set_category_link_to_child(child->link_to_child);
791
ch_ptr->set_category_link_to_child(child->link_to_child);
880
792
881
793
if (child->child_category != "")
882
ch.set_child_category(child->child_category);
794
ch_ptr->set_child_category(child->child_category);
883
795
884
796
if (child->using_child_category_max_results)
885
ch.set_child_category_max_results(child->child_category_max_results);
797
ch_ptr->set_child_category_max_results(child->child_category_max_results);
886
798
887
int card = get_setting_cardinality();
799
int card = get_cardinality_setting();
888
800
if (card > 0)
889
ch.set_cardinality(card);
801
ch_ptr->set_cardinality(card);
890
802
if (child->cardinality >= -1) // let declared override user settings
891
ch.set_cardinality(child->cardinality);
803
ch_ptr->set_cardinality(child->cardinality);
892
804
893
805
if (!child->first_result_template.empty())
894
ch.set_first_result_template(child->first_result_template);
806
ch_ptr->set_first_result_template(child->first_result_template);
895
807
896
808
if (child->overriding_surface_template)
897
809
{
898
ch.set_surface_template(child->surface_template);
810
ch_ptr->set_surface_template(child->surface_template);
899
811
}
900
812
else
901
ch.set_override_surface_template(false);
813
{
814
ch_ptr->set_override_surface_template(false);
815
}
902
816
903
817
if (child->overriding_search_template)
904
818
{
905
ch.set_search_template(child->search_template);
819
ch_ptr->set_search_template(child->search_template);
906
820
}
907
821
else
908
ch.set_override_search_template(false);
909
910
ch.set_only_in_search(child->only_in_search);
911
912
ch.set_source_finder(child->source_finder);
913
qWarning () << QString("%1: ADDING DECLARED child scope: %2, local_id: %3").arg(qstr(scope_id), qstr(ch.id()), qstr(ch.local_id()));
914
scopes_m[ch.local_id()] = std::make_shared<AggChildScope>(ch);
915
current_scopes.emplace_back(ch.local_id());
916
822
{
823
ch_ptr->set_override_search_template(false);
824
}
825
826
ch_ptr->set_only_in_search(child->only_in_search);
827
828
ch_ptr->set_source_finder(child->source_finder);
829
qWarning () << QString("%1: ADDING DECLARED child scope: %2, local_id: %3")
830
.arg(qstr(agg_scope_->scope_id()), qstr(ch_ptr->id()), qstr(ch_ptr->local_id()));
831
scopes_m[ch_ptr->local_id()] = ch_ptr;
832
current_scopes.emplace_back(ch_ptr->local_id());
917
833
}
918
return;
919
834
}
920
835
921
836
void Query::create_departments(us::SearchReplyProxy const &reply_)
922
837
{
923
838
//create depts for declared keywords
924
for (auto item : keyword_deptTitleMsgid)
839
for (const auto & item : keyword_deptTitleMsgid)
925
840
{
926
841
auto iter = keyword_deptId.find(item.first);
927
842
if (iter != keyword_deptId.end())
928
843
{
929
844
continue;
930
845
}
931
dept d;
932
d.title = _(item.second.c_str());
933
d.id = item.first;
934
depts[d.id] = std::make_shared<dept>(d);
846
auto dept_ptr = std::make_shared<dept>();
847
dept_ptr->title = _(item.second.c_str());
848
dept_ptr->id = item.first;
849
depts[dept_ptr->id] = dept_ptr;
935
850
}
936
851
852
if (dept_id_of_root.empty())//means no declared scopes, only keywords
853
dept_id_of_root = dept_id_of_root_keywords_only;
854
937
855
us::DepartmentList depts_;
938
856
us::CannedQuery cannedQuery("aggregator");
939
if (dept_id_of_root.empty())//means no declared scopes, only keywords
940
dept_id_of_root = dept_id_of_root_keywords_only;
941
857
cannedQuery.set_department_id(dept_id_of_root);
942
us::Department::SPtr topDept;
943
topDept = move(us::Department::create("", cannedQuery, depts[dept_id_of_root]->title));
944
for ( auto & item : depts)
858
us::Department::SPtr topDept = move(us::Department::create("", cannedQuery, depts[dept_id_of_root]->title));
859
for (const auto & item : depts)
945
860
{
946
861
if (item.first == dept_id_of_root)
947
862
continue;
960
875
{
961
876
for (auto const& keyword_child : current_child_scopes)
962
877
{
963
964
878
if (!keyword_child.enabled)
965
879
continue;
966
967
968
AggChildScope keych(keyword_child.id);
880
auto keych_ptr = std::make_shared<AggChildScope>(keyword_child.id);
969
881
QString time_str = QDateTime::currentDateTimeUtc().toString();
970
keych.set_keyword_scope(true);
971
dept d;
972
d.id = keyword_child.id;
882
keych_ptr->set_keyword_scope(true);
883
auto dept_ptr = std::make_shared<dept>();
884
dept_ptr->id = keyword_child.id;
973
885
std::string id = keyword_child.id;
974
886
bool found = false;
975
887
for (auto kw : declared_keywords)
994
906
if (iter1 != current_scopes.end()) // don't add as keyword if already added as declared
995
907
continue;
996
908
997
keych.set_local_id(keyword_child.id + ":" + kw);
998
type_ids_m[kw].emplace_back(keych.local_id());
999
d.keyword = kw;
1000
keych.set_department(kw);
1001
keych.set_keyword(kw);
1002
keych.set_category_link_to_child(id_keyword_map[kw]->link_to_child);
909
keych_ptr->set_local_id(keyword_child.id + ":" + kw);
910
type_ids_m[kw].emplace_back(keych_ptr->local_id());
911
dept_ptr->keyword = kw;
912
keych_ptr->set_department(kw);
913
keych_ptr->set_keyword(kw);
914
keych_ptr->set_category_link_to_child(id_keyword_map[kw]->link_to_child);
1003
915
if (!keyword_catname_renderer[kw].empty())
1004
916
{
1005
917
qDebug()<< "==== UTILs. adding renderer to: " << qstr(keyword_child.id);
1006
keych.set_surface_template(keyword_catname_renderer[kw]);// this is overwritten below for shared cat scopes
918
keych_ptr->set_surface_template(keyword_catname_renderer[kw]);// this is overwritten below for shared cat scopes
1007
919
}
1008
920
else
921
{
1009
922
qDebug()<< "==== UTILs. renderer not declared: " << qstr(keyword_child.id);
923
}
1010
924
1011
925
bool a_dup = false;
1012
926
// if this keyword scope is already a declared scope in the current dept, don't add it
1021
935
1022
936
for (std::shared_ptr<child_scope> cs : child_scopes)
1023
937
{
1024
if (keych.local_id() != cs->id)
938
if (keych_ptr->local_id() != cs->id)
1025
939
continue;
1026
940
if (curr_dept_id == "")
1027
941
{
1047
961
if (keyword_deptId.find(kw) != keyword_deptId.end())
1048
962
{
1049
963
// keyword is declared to use declared department, so use it
1050
keych.set_department(keyword_deptId[kw]);
964
keych_ptr->set_department(keyword_deptId[kw]);
1051
965
}
1052
966
else
1053
967
{
1054
depts[kw] = std::make_shared<dept>(d);
968
depts[kw] = dept_ptr;
1055
969
}
1056
970
}
1057
971
1059
973
if (iter != shared_keywords.end())
1060
974
{
1061
975
//qWarning() << "==== ID JUST set kw: "<< qstr(keych.keyword());
1062
qDebug() << QString("==== UTILs. set ky scope kw %1 as a a shared cat in kw: %2").arg(qstr(keych.id()), qstr(kw));
1063
keych.set_keyword_scope_shared_cat_name(shared_keyword_cats[kw]);
976
qDebug() << QString("==== UTILs. set ky scope kw %1 as a a shared cat in kw: %2").arg(qstr(keych_ptr->id()), qstr(kw));
977
keych_ptr->set_keyword_scope_shared_cat_name(shared_keyword_cats[kw]);
1064
978
1065
979
//initially the category is set to false meaning there have been
1066
980
//no results yet for it and it has not yet been registered
1071
985
qDebug() << "===== UTILs. keywordSharedCat_isFirstResult[kw] " << keywordSharedCat_isFirstResult[kw];
1072
986
keywordSharedCat_isSecondResult[kw] = false;
1073
987
qDebug() << "===== UTILs. kw shared surface: " << qstr(keyword_catname_renderer[kw]).replace("\n"," ");
1074
keych.set_surface_template(keyword_catname_renderer[kw]);
988
keych_ptr->set_surface_template(keyword_catname_renderer[kw]);
1075
989
// if (keyword_catname_first_result_renderers[kw].empty())
1076
990
// keych.set_first_resulte_template(keyword_catname_first_result_renderer[kw]);
1077
991
}
1085
999
std::string curr_dept_id = query().department_id();
1086
1000
if (curr_dept_id.empty())
1087
1001
curr_dept_id = "root";
1088
qWarning() << "==== ID 2 KEYWORD: " << qstr(keych.keyword());
1089
qWarning () << QString("%1: ADDING KEYWORD child scope: %2, local_id %3, by keyword %4, to department: %5").arg(qstr(scope_id), qstr(keych.id()), qstr(keych.local_id()), qstr (keych.keyword()), qstr(curr_dept_id));
1090
scopes_m[keych.local_id()] = std::make_shared<AggChildScope>(keych);
1091
localId_id_m[keych.local_id()] = keych.id();
1092
current_scopes.emplace_back(keych.local_id());
1002
qWarning() << "==== ID 2 KEYWORD: " << qstr(keych_ptr->keyword());
1003
qWarning () << QString("%1: ADDING KEYWORD child scope: %2, local_id %3, by keyword %4, to department: %5")
1004
.arg(qstr(agg_scope_->scope_id()), qstr(keych_ptr->id()), qstr(keych_ptr->local_id()), qstr (keych_ptr->keyword()), qstr(curr_dept_id));
1005
scopes_m[keych_ptr->local_id()] = keych_ptr;
1006
localId_id_m[keych_ptr->local_id()] = keych_ptr->id();
1007
current_scopes.emplace_back(keych_ptr->local_id());
1093
1008
}
1094
1009
}
1095
1010
1106
1021
{
1107
1022
qDebug() << "==== MKCAT SCOPE scope id"<< qstr(ids.first);
1108
1023
qDebug() << "==== MKCAT SCOPE scope loca_id"<< qstr(ids.second);
1109
AggChildScope scope(ids.first);
1110
scope.set_category_scope(true);
1111
scope.set_category_id(cat->id);
1024
auto scope_ptr = std::make_shared<AggChildScope>(ids.first);
1025
scope_ptr->set_category_scope(true);
1026
scope_ptr->set_category_id(cat->id);
1112
1027
qDebug() << "==== MKCAT SCOPE cat card"<< QString::number(cat->cardinality);
1113
scope.set_cardinality(cat->cardinality);
1114
qDebug() << "==== MKCAT SCOPE get cat card"<< QString::number(scope.cardinality());
1115
scope.set_local_id(ids.second);
1028
scope_ptr->set_cardinality(cat->cardinality);
1029
qDebug() << "==== MKCAT SCOPE get cat card"<< QString::number(scope_ptr->cardinality());
1030
scope_ptr->set_local_id(ids.second);
1116
1031
if (!scopeLocalId_childDept_m[ids.second].empty())
1117
1032
{
1118
scope.set_child_department(scopeLocalId_childDept_m[ids.second]);
1033
scope_ptr->set_child_department(scopeLocalId_childDept_m[ids.second]);
1119
1034
}
1120
scope.set_surface_template(cat->renderer);
1121
scope.set_search_template(cat->search_renderer);
1035
scope_ptr->set_surface_template(cat->renderer);
1036
scope_ptr->set_search_template(cat->search_renderer);
1122
1037
if (using_departments)
1123
scope.set_department(cat->dept_id);
1038
scope_ptr->set_department(cat->dept_id);
1124
1039
qDebug() << "==== MKCAT SCOPE cat dept_id"<< qstr(cat->dept_id);
1125
qDebug() << "==== MKCAT SCOPE scope dept_id"<< qstr(scope.department());
1126
scope.set_keyword_scope(false);
1127
scopes_m[scope.local_id()] = std::make_shared<AggChildScope>(scope);
1128
type_ids_m[cat->id].emplace_back(scope.local_id());
1129
localId_id_m[scope.local_id()] = scope.id();
1130
current_scopes.emplace_back(scope.local_id());
1131
qWarning () << QString("%1: ADDING CATEGORY SCOPE child scope: %2 to dept %3").arg(qstr(scope_id), qstr(scope.local_id()), qstr(scope.department()));
1040
qDebug() << "==== MKCAT SCOPE scope dept_id"<< qstr(scope_ptr->department());
1041
scope_ptr->set_keyword_scope(false);
1042
scopes_m[scope_ptr->local_id()] = scope_ptr;
1043
type_ids_m[cat->id].emplace_back(scope_ptr->local_id());
1044
localId_id_m[scope_ptr->local_id()] = scope_ptr->id();
1045
current_scopes.emplace_back(scope_ptr->local_id());
1046
qWarning () << QString("%1: ADDING CATEGORY SCOPE child scope: %2 to dept %3")
1047
.arg(qstr(agg_scope_->scope_id()), qstr(scope_ptr->local_id()), qstr(scope_ptr->department()));
1132
1048
}
1133
1049
1134
1135
1050
for (auto const& keyword_child : current_child_scopes)
1136
1051
{
1137
1052
qDebug() << "==== CATKW id START ";
1139
1054
continue;
1140
1055
1141
1056
std::string id = keyword_child.id;
1142
AggChildScope keych(id);
1143
1057
for (auto kw : cat->keywords)
1144
1058
{
1145
1059
qDebug() << "==== CATKW child id: " << qstr(id);
1157
1071
continue;
1158
1072
1159
1073
qDebug() << qstr("==== CATKW ID found: %1 %2").arg(qstr(kw),qstr(id));
1160
AggChildScope keych(id);
1074
auto keych_ptr = std::make_shared<AggChildScope>(id);
1161
1075
std::string local_id = id + ":category=" + cat->id + ":keyword=" + kw;
1162
keych.set_local_id(local_id);
1163
keych.set_category_link_to_child(false);//TODO revisit
1164
keych.set_category_scope(true);
1165
keych.set_category_id(cat->id);
1076
keych_ptr->set_local_id(local_id);
1077
keych_ptr->set_category_link_to_child(false);//TODO revisit
1078
keych_ptr->set_category_scope(true);
1079
keych_ptr->set_category_id(cat->id);
1166
1080
qDebug() << "==== CATKW adding id: " << qstr(id);
1167
1081
qDebug() << "==== CATKW adding kw: " << qstr(kw);
1168
type_ids_m[cat->id].emplace_back(keych.local_id());
1169
keych.set_keyword(kw);
1170
qDebug() << "==== CATKW: " << qstr(keych.keyword());
1171
keych.set_department(cat->dept_id);
1172
keych.set_department(cat->dept_id);
1173
keych.set_cardinality(cat->cardinality);
1082
type_ids_m[cat->id].emplace_back(keych_ptr->local_id());
1083
keych_ptr->set_keyword(kw);
1084
qDebug() << "==== CATKW: " << qstr(keych_ptr->keyword());
1085
keych_ptr->set_department(cat->dept_id);
1086
keych_ptr->set_department(cat->dept_id);
1087
keych_ptr->set_cardinality(cat->cardinality);
1174
1088
1175
1089
// set more default values
1176
1090
categoryId_isFirstResult[kw] = true;
1177
1091
categoryId_isSecondResult[kw] = false;
1178
keych.set_surface_template(cat->renderer);
1179
keych.set_search_template(cat->search_renderer);
1092
keych_ptr->set_surface_template(cat->renderer);
1093
keych_ptr->set_search_template(cat->search_renderer);
1180
1094
1181
1095
if (categoryId_firstRdrs_catId2commonId.find(cat->id) != categoryId_firstRdrs_catId2commonId.end())
1182
1096
{
1183
keych.set_first_common_template_id(categoryId_firstRdrs_catId2commonId[cat->id]);
1097
keych_ptr->set_first_common_template_id(categoryId_firstRdrs_catId2commonId[cat->id]);
1184
1098
}
1185
1099
if (categoryId_surfaceRdrs_catId2commonId.find(cat->id) != categoryId_surfaceRdrs_catId2commonId.end())
1186
1100
{
1187
keych.set_surface_common_template_id(categoryId_surfaceRdrs_catId2commonId[cat->id]);
1101
keych_ptr->set_surface_common_template_id(categoryId_surfaceRdrs_catId2commonId[cat->id]);
1188
1102
}
1189
1103
1190
qWarning () << QString("%1: ADDING CATEGORY KEYWORD child scope: %2, by keyword %3, to department: %4").arg(qstr(scope_id), qstr(keych.id()), qstr(kw), qstr(cat->dept_id));
1191
scopes_m[keych.local_id()] = std::make_shared<AggChildScope>(keych);
1192
localId_id_m[keych.local_id()] = keych.id();
1193
current_scopes.emplace_back(keych.local_id());
1104
qWarning () << QString("%1: ADDING CATEGORY KEYWORD child scope: %2, by keyword %3, to department: %4")
1105
.arg(qstr(agg_scope_->scope_id()), qstr(keych_ptr->id()), qstr(kw), qstr(cat->dept_id));
1106
1107
scopes_m[keych_ptr->local_id()] = keych_ptr;
1108
localId_id_m[keych_ptr->local_id()] = keych_ptr->id();
1109
current_scopes.emplace_back(keych_ptr->local_id());
1194
1110
current_scopeIds.emplace_back(id);
1195
1111
}
1196
1112
}
1263
1179
reply->push(res);
1264
1180
}
1265
1181
1266
void Query::load_hints_config()
1267
{
1268
// try to open hints.json and get vals, else no hints
1269
if (!load_json_file(root, scope_dir_ + "/hints.json", scope_id))
1270
{
1271
return;
1272
}
1273
if (root.contains("using_hints"))
1274
{
1275
if (root["using_hints"].toString() == TRUE)
1276
uses_hints = true;
1277
else
1278
return;
1279
}
1280
else
1281
return;
1282
if (root.contains("hints_source"))
1283
{
1284
if (root["hints_source"].toString() == "local")
1285
{
1286
local_hints = true;
1287
if (root.contains("local")) {
1288
hints_local_json = root["local"].toObject();
1289
}
1290
}
1291
}
1292
else
1293
return;
1294
if (root.contains("quick_start_help"))
1295
if (sstr(root["quick_start_help"].toString()) == TRUE)
1296
hints_quickstart = true;
1297
if (root.contains("message_on_no_network"))
1298
if (sstr(root["message_on_no_network"].toString()) == TRUE)
1299
no_network_msg = true;
1300
if (root.contains("message_on_no_location"))
1301
if (sstr(root["message_on_no_location"].toString()) == TRUE)
1302
no_location_msg = true;
1303
if (!local_hints)
1304
{
1305
if (root.contains("hints_scope"))
1306
{
1307
QJsonObject hints_scope = root["hints_scope"].toObject();
1308
if (hints_scope.contains("hints_scope_id"))
1309
HINTS_SCOPE_ID = sstr(hints_scope["hints_scope_id"].toString());
1310
else
1311
uses_hints = false;
1312
if (hints_scope.contains("hints_this_scope"))
1313
HINTS_THIS_SCOPE = sstr(hints_scope["hints_this_scope"].toString());
1314
else
1315
uses_hints = false;
1316
//this key is deprecated. it previously specified the query string the hints scope
1317
//sent to the agg scope to signal hints quick start should be permanently dismissed.
1318
//scope-aggregator 4.4 stopped using this.
1319
if (hints_scope.contains("hints_hide"))
1320
HINTS_HIDE = sstr(hints_scope["hints_hide"].toString());
1321
else
1322
uses_hints = false;
1323
}
1324
}
1325
return;
1326
}
1327
1328
1182
bool Query::hints_exists()
1329
1183
{
1330
1184
auto scopes = registry_->list();
1342
1196
{
1343
1197
if (!local_hints)
1344
1198
return;
1345
if (!hints_local_json.contains("content"))
1199
if (!hints_local_json.contains(QStringLiteral("content")))
1346
1200
return;
1347
auto content = hints_local_json["content"].toObject();
1348
if (!content.contains("categories"))
1201
auto content = hints_local_json[QStringLiteral("content")].toObject();
1202
if (!content.contains(QStringLiteral("categories")))
1349
1203
return;
1350
1204
1351
QJsonArray cats = content["categories"].toArray();
1205
QJsonArray cats = content[QStringLiteral("categories")].toArray();
1352
1206
for (const auto & cat_ : cats)
1353
1207
{
1354
1208
auto cat = cat_.toObject();
1355
1209
1356
std::string id = sstr(cat["id"].toString());
1357
std::string title = _(sstr(cat["_title"].toString()).c_str());
1358
QJsonDocument layout_d(cat["layout"].toObject());
1210
std::string id = sstr(cat[QStringLiteral("id")].toString());
1211
std::string title = _(sstr(cat[QStringLiteral("_title")].toString()).c_str());
1212
QJsonDocument layout_d(cat[QStringLiteral("layout")].toObject());
1359
1213
std::string local_hints_template = sstr(layout_d.toJson());
1360
1214
auto category = upstream_reply_->lookup_category(id);
1361
1215
if (!category) {
1362
1216
category = upstream_reply_->register_category(id, title, "", us::CategoryRenderer(local_hints_template));
1363
1217
}
1364
QJsonArray items = cat["items"].toArray();
1218
QJsonArray items = cat[QStringLiteral("items")].toArray();
1365
1219
for (const auto & res__ : items)
1366
1220
{
1367
1221
auto res_ = res__.toObject();
1368
1222
us::CategorisedResult res(category);
1369
res.set_title(_(sstr(res_["_title"].toString()).c_str()));
1370
res["subtitle"] = _(sstr(res_["_subtitle"].toString()).c_str());
1371
res["description"] = _(sstr(res_["_description"].toString()).c_str());
1223
res.set_title(_(sstr(res_[QStringLiteral("_title")].toString()).c_str()));
1224
res["subtitle"] = _(sstr(res_[QStringLiteral("_subtitle")].toString()).c_str());
1225
res["description"] = _(sstr(res_[QStringLiteral("_description")].toString()).c_str());
1372
1226
std::string uri = "http://www.ubuntu.com";
1373
1227
if (res_.contains("uri"))
1374
1228
{
1375
1229
uri = sstr(res_["uri"].toString());
1376
1230
}
1377
if (res_.contains("action"))
1231
if (res_.contains(QStringLiteral("action")))
1378
1232
{
1379
auto action = res_["action"].toObject();
1233
auto action = res_[QStringLiteral("action")].toObject();
1380
1234
VariantBuilder builder;
1381
1235
builder.add_tuple({
1382
1236
{"id", Variant("Open")},
1383
{"label", Variant(_(sstr(action["_name"].toString()).c_str()))},
1384
{"uri", Variant(sstr(action["uri"].toString()))}
1237
{"label", Variant(_(sstr(action[QStringLiteral("_name")].toString()).c_str()))},
1238
{"uri", Variant(sstr(action[QStringLiteral("uri")].toString()))}
1385
1239
});
1386
1240
res["actions"]=builder.end();
1387
if (action.contains("uri"))
1241
if (action.contains(QStringLiteral("uri")))
1388
1242
{
1389
uri = sstr(action["uri"].toString());
1243
uri = sstr(action[QStringLiteral("uri")].toString());
1390
1244
}
1391
1245
}
1392
if (res_.contains("oaccount"))
1246
if (res_.contains(QStringLiteral("oaccount")))
1393
1247
{
1394
auto oaccount = res_["oaccount"].toObject();
1395
auto queryScope = sstr(oaccount["QueryScope"].toString());
1248
auto oaccount = res_[QStringLiteral("oaccount")].toObject();
1249
auto queryScope = sstr(oaccount[QStringLiteral("QueryScope")].toString());
1396
1250
1397
us::OnlineAccountClient oa_client(sstr(oaccount["ServiceName"].toString()),
1398
sstr(oaccount["ServiceType"].toString()),
1399
sstr(oaccount["ProviderName"].toString()));
1251
us::OnlineAccountClient oa_client(sstr(oaccount[QStringLiteral("ServiceName")].toString()),
1252
sstr(oaccount[QStringLiteral("ServiceType")].toString()),
1253
sstr(oaccount[QStringLiteral("ProviderName")].toString()));
1400
1254
bool alreadyLoggedIn = false;
1401
1255
oa_client.refresh_service_statuses();
1402
1256
auto vectoraccounts = oa_client.get_service_statuses();
1403
bool loggedIn;
1404
1257
for (auto const& status : oa_client.get_service_statuses())
1405
1258
{
1406
1259
if (status.service_enabled)
1407
1260
{
1408
1261
alreadyLoggedIn = true;
1409
loggedIn = true;
1410
1262
break;
1411
1263
}
1412
1264
}
1426
1278
OnlineAccountClient::DoNothing);
1427
1279
1428
1280
}
1429
if (res_.contains("hide_hints"))
1281
if (res_.contains(QStringLiteral("hide_hints")))
1430
1282
{
1431
1283
qDebug() << "=== NHINTS. utils. hide hints found in json";
1432
1284
res["action"] = "hide_hints";
1459
1311
auto filepath2 = QString::fromStdString(cache_dir_) +"/" + firstboot;
1460
1312
if (QFile::exists(filepath1) || QFile::exists(filepath2))
1461
1313
return true;
1462
else
1463
return false; //don't show hints as fall back
1314
return false; //don't show hints as fall back
1464
1315
}
1465
1316
1466
1317
void Query::dismiss_hints_quickstart() {
Loggerhead is a web-based interface for Breezy
Version: 2.0.1