Merge lp:~knitzsche/scope-aggregator/featured into lp:scope-aggregator

[Kyle Nitzsche]

This implements the new "Featured Result" feature.

The basic idea is declaring a category that shows a single result. Dev declares a set of scopes to pull from. On each refresh, the result is pulled from the next "pull from" scope, cycling through them and wrapping to the start.

Specification document:
https://docs.google.com/document/d/17_Pw4B86hnfIu1slIc2_qFVeKiOdU2KVXHbyMDxosrs/edit#heading=h.gftd6k6aluuu

I tested the built .so in Today, News, Nearby and Photos. All looks good (their behavior is unchanged).

You can test the new feature by installing the scopes as explained in "Working Sample" section of the specification doc linked above.

Note: README.md file in source should completed explain the new "featured" support.

[Zhang Enwei (zhangew401)]

LGTM except not suppress the log.
I verified on china-dashboard and news-china.

review: Approve

[Jin (jindallo)]

Code looks good and verified pass on my local,
I approve.

review: Approve

[lp:~knitzsche/scope-aggregator/featured]

205. By Kyle Nitzsche on 2016-11-10

fix typo in readme

206. By Kyle Nitzsche on 2016-11-10

supress log output

=== modified file 'README.md'
--- README.md	2016-11-02 13:36:29 +0000
+++ README.md	2016-11-10 18:47:16 +0000
@@ -2,7 +2,7 @@
 
 This is a *declarative* aggregator scope template. You declare aggregated scopes and keywords for inclusion in json files.
 
-You may combine the various text files and icons with the built scope-aggregator .so file into a click package, thus creating rich aggregator scopes with no c++ coding and compilation.
+You may combine the various text files and icons with the built scope-aggregator .so file into a package, thus creating rich aggregator scopes with no c++ coding and compilation.
 
 Here are couple examples:
 
@@ -16,6 +16,7 @@
  * `scope`: includes a single scope
  * `category`: includes a set of scopes and keywords
  * `keyword`: includes child scopes that answer to the keywords
+ * `featured`: displays a single result on each refresh by cycling through a declared set of scopes 
 
 These are declared directly inside the `order` json list element. The order of declaration determines the order of presentation in the aggregator scope, with the exception of `keyword` (explained below)
 
@@ -24,6 +25,7 @@
  * `scope`: A single Category is created for each `scope`. It contains all results from the scope. The Category displays in the declared order.
  * `category`: A single Category is created for each `category`. It contains all results from the internally declared set of scopes and from all present scopes that answer to the internally declared set of keywords. The Category displays in the declared order.
  * `keyword`: A Category is created for each scope that answers to the declared keyword. By default, the only guarantee relating to the overall order is that the first such child scope appears in the declared order. Categories for all other scopes that answer to the keyword display in an determinant order (but always after the first). You can use the additional `display_order` feature to set the order of child scopes answering to this keyword.
+ * `featured`: A single Category is created for each `featured` that has at least one installed and enabled `pull_from` child scope. It contains a single result: the first result supplied by the current `pull_from` child scope. On each refresh, the next `pull_from` child scope is queried. After the final `pull_from` child scope, on refresh the first `pull_from` child scope is used.
 
 ## Departments
 
@@ -39,13 +41,13 @@
 
 ## Categories
 
-As noted, a Category is automatically created for each `scope`, `category`, and for each scope answering to a `keyword`.
+As noted, a Category is automatically created for each `scope`, `category`, `featured`, and for each scope answering to a `keyword`.
 
 You can set various Category items, including title, renderers, and, whether tapping the category header (which displays the title) switches focus to another child scope (called "link to child"). 
 
-By default, the link to child feature is enabled for `scope` and `keyword` categories. It can be disabled with `"link_to_child": "false"`.
+By default, the link to child feature is enabled for `scope`, `keyword` and `featured` categories. It can be disabled with `"link_to_child": "false"`. For `featured` objects, the link to child points to the scope providing the current featured result.
 
-For `category` declaration, the link to child feature may or may not make sense. By default, there is no link to child for `category`. But, if the `category` always and only contains a single child scope, it usually makes sense. This is enabled with `"link_to_child_specified": "scope ID"`.
+For `category` declaration, the link to child feature may or may not be appropriate. By default, there is no link to child for `category`. But, if the `category` always and only contains a single child scope, it usually makes sense. This is enabled with `"link_to_child_specified": "scope ID"`.
 
 But, when a `category` contains multiple child scopes, either when the `category` is declared with more than one child scope or when it is declared to include a keyword (which may result in multiple child scopes, link to child may not be appropriate because there may be no reasonable single child scope to link to. But even with multiple child scopes, link to child may still be appropriate: for example, the Today scope has a `category` that aggregates news headlines. It has a link to child that takes the user to the News scope
 Headlines department. 
@@ -65,9 +67,9 @@
 
 In general, when no render is declared, the renderer is taken from the first incoming result in the Category. This works, but the layout and design is not in control of the aggregator scope developer, and there is no consistency in the layout and design among the multiple child scopes displayed. Therefore, designing and declaring renderers is a critical part for aggregator scope development.
 
-Typically you declare your renderers right inside your `scope`, `category` or `keyword` object. 
+Typically you declare your renderers right inside your `scope`, `category`, `featured`, and `keyword` object. 
 
-If you wish to declare renderers once and reuse them, you may declare each type of renderer (except for the login renderer) once in a `common_templates` object and  include them by ID inside your `scope`, `category` or `keyword` object, as explained below.
+If you wish to declare renderers once and reuse them, you may declare each type of renderer (except for the login renderer) once in a `common_templates` object and  include them by ID inside your `scope`, `category`, `featured` or `keyword` object, as explained below.
 
 ## Cardinality
 
@@ -82,6 +84,8 @@
 
 You may use both approaches simultaneously. If so, declared cardinality for `scope`, `category` and `keyword` preempts settings.
 
+Cardinality for `featured` objects is hard coded to 1 and cannot be modified. 
+
 ### Cardinality with scope settings
 
 Suppose you want the user to choose between cardinality of 1,2,4, and 8, and you want the default to be 2. Here is your settings.ini:
@@ -138,7 +142,7 @@
 
 Fallbacks allows you to declare that for a given attribute in your renderer (for example "art"), you want to check a specified series of fields in the incoming result and use the first one that exists. For example, to get a value for your "art" field, you might want to check the "art" field, then the "mascot" field, and finally the "emblem" field of each incoming result. 
 
-This is currently support using `common_templates`. Your template in common templates declares a `fallbacks` object. And of course, you declare a renderer to use the common template (instead of being declared in place).
+This is currently supported using `common_templates`. Your template in common templates declares a `fallbacks` object. And of course, you declare a renderer to use the common template (instead of being declared in place).
 
 This example accomplishes the above goal:
 
@@ -179,10 +183,10 @@
 
 * `departments`: Here you declared your departments or declare you do not want departments
 * `cardinality`: Here you declared cardinality options for use with scope settings.
-* `order`: Here you declare your specific scopes, keywords and categories for aggregation
-* `commmon_templates`: Here you declare category renderer templates you may use for multiple specified categories
+* `order`: Here you declare your specific `scope`, `keyword`, `featured`s, and `category`s for aggregation
+* `commmon_templates`: Here you declare category renderer templates you may reuse conveniently
 
-The order of these objects in the file has no affect.
+The order of these top level objects in the file has no consequence.
 
 ## `departments` (optional)
 
@@ -289,6 +293,13 @@
             "order":
             [
                 {
+                    "featured":
+                    {
+                        [...]
+                    },
+                },
+
+                {
                     "scope":
                     {
                         [...]
@@ -576,6 +587,62 @@
         }
         [...]
 
+### `featured` (optional)
+
+A `featured` object displays a single result on each refresh from the current `pull_from` child scope. On each refresh, the next `pull_from` child scope is used. All `pull_from` scopes must be separately declared as `scope` objects. The idea is that the featured category cycles through a set of declared scopes on each refresh, displaying the first result from the current scope. Scopes that are not installed and enabled (in the aggregator scope settings) are excluded from the `pull_from` list. If there are no current `pull_from` scopes, the featured category does not display. Featured categories do not display when a user enters a search string.
+
+ * A unique `id` is required.
+ * The rendered can be set with `renderer` or with a `renderer_common_id`.
+ * The category title can be hard coded and unvarying: set it with`_title` (child of `featured`). 
+ * The category title can vary depending on the current child scope: set it for each child scope as shown below.
+ * `_title` supports i18n/l10n.
+ * By default, the Category has a link to the current child scope. This can be disabled with `"link_to_child": "false"`.
+ * Mutiple `featured` object are supported.
+ * `featured` objects may be used with Departments.
+ * Cardinality is hard coded to 1.
+ * Fallbacks are supported when using `renderer_common_id` with `common_templates`.
+
+In this example, the category title varies with the current child scope and a link to current child scope is provided.
+
+        {
+            "featured": {
+                "id": "featured_1",
+                "department": "dept1",
+                "pull_from":[
+                    {
+                        "id": "developerx.mymoviechannel_movies",
+                        "_title": "Featured: My Movies"
+                    },
+                    {
+                        "id": "developery.hotmovies_movies",
+                        "_title": "Featured: Hot Movies"
+                    }
+                ],
+                "renderer_common_id": "featured_template_1",
+            }
+        },
+
+In this example, the category title is set once (it never changes) and link to child is not present.
+
+        {
+            "featured": {
+                "id": "featured_1",
+                "department": "dept1",
+                 "_title": "Featured: Movies",
+                "link_to_child": "false",
+                "pull_from":[
+                    {
+                        "id": "developerx.mymoviechannel_movies",
+                    },
+                    {
+                        "id": "developery.hotmovies_movies",
+                    }
+                ],
+                "renderer_common_id": "featured_template_1",
+            }
+        },
+
+
 ### `category` (optional)
 
 You can declare a category that includes a specified set of scopes and keywords. All results from these child scopes are displayed in a single category.

=== modified file 'gtests/CMakeLists.txt'
--- gtests/CMakeLists.txt	2016-09-22 16:39:29 +0000
+++ gtests/CMakeLists.txt	2016-11-10 18:47:16 +0000
@@ -76,6 +76,7 @@
     COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/scope_directory/login_1.json" "${CMAKE_CURRENT_BINARY_DIR}/scope_directory/login_1.json"
     COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/scope_directory/login_2.json" "${CMAKE_CURRENT_BINARY_DIR}/scope_directory/login_2.json"
     COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/scope_directory/login_3.json" "${CMAKE_CURRENT_BINARY_DIR}/scope_directory/login_3.json"
+    COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/scope_directory/featured_1.json" "${CMAKE_CURRENT_BINARY_DIR}/scope_directory/featured_1.json"
     COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}/cache_directory"
 )
 

=== modified file 'gtests/MockRegistry.h'
--- gtests/MockRegistry.h	2016-09-21 17:24:06 +0000
+++ gtests/MockRegistry.h	2016-11-10 18:47:16 +0000
@@ -154,13 +154,25 @@
         {
            mm.insert(pair<string, ScopeMetadata>("full_keyword_3", full_keyword_3));
         }
-
         set<string> keywords_login = {"login-test"};
         auto login_metadata = build_scope_metadata("login-test", keywords_login);
         if (predicate(login_metadata))
         {
            mm.insert(pair<string, ScopeMetadata>("login-test", login_metadata));
         }
+        set<string> keywords_none = {};
+        auto featured_1_metadata = build_scope_metadata("featured_1", keywords_none);
+        if (predicate(featured_1_metadata))
+        {
+           mm.insert(pair<string, ScopeMetadata>("featured_1", featured_1_metadata));
+        }
+        auto featured_2_metadata = build_scope_metadata("featured_2", keywords_none);
+        if (predicate(featured_2_metadata))
+        {
+           mm.insert(pair<string, ScopeMetadata>("featured_2", featured_2_metadata));
+        }
+ 
+
         return mm;
     }
 };

=== added file 'gtests/scope_directory/featured_1.json'
--- gtests/scope_directory/featured_1.json	1970-01-01 00:00:00 +0000
+++ gtests/scope_directory/featured_1.json	2016-11-10 18:47:16 +0000
@@ -0,0 +1,398 @@
+{
+    "departments":
+    {
+        "do_not_use_departments": "false",
+        "declarations":
+        [
+            {
+                "id": "dept1",
+                "root": "true",
+                "_title": "Dept 1"
+            },
+            {
+                "id": "dept2",
+                "root": "False",
+                "_title": "Dept 2"
+            },
+            {
+                "id": "dept3",
+                "root": "False",
+                "_title": "Dept 3"
+            }
+        ]
+    }, 
+    "common_templates": [
+        {
+        "id": "news",
+            "fallbacks": [
+                {
+                    "fields": [
+                        {
+                            "field": "art"
+                        },
+                        {
+                            "field": "mascot"
+                        },
+                        {
+                            "field": "emblem"
+                        }
+                    ],
+                    "key": "art"
+                }
+            ],
+            "template": {
+                "components": {
+                    "art": "art",
+                    "attributes": "attributes",
+                    "subtitle": "published",
+                    "title": "title"
+                },
+                "schema-version": 1,
+                "template": {
+                    "card-size": "medium",
+                    "category-layout": "horizontal-list",
+                    "collapsed-rows": 1
+                }
+            }
+        },
+        {
+            "id": "not_logged_in",
+            "template": {
+                "components": {
+                    "mascot": "art",
+                    "title": "title"
+                },
+                "schema-version": 1,
+                "template": {
+                    "card-layout": "horizontal",
+                    "card-size": "large",
+                    "category-layout": "grid"
+                }
+            }
+        }
+    ],
+    "order": [
+        {
+            "featured": {
+                "id": "featured",
+                "department": "dept1",
+                "NOT_title": "Featured",
+                "link_to_child": "falseNOT",
+                "pull_from":[
+                    {
+                        "id": "featured_1",
+                        "_title": "Featured: One"
+                    },
+                    {
+                        "id": "featured_2",
+                        "_title": "Featured: Two"
+                    }
+                ],
+                "renderer_common_id": "news",
+                "NOTrenderer": {
+                    "components": {
+                        "subtitle": "subtitle",
+                        "title": "title",
+                        "art": {
+                            "field": "art",
+                            "aspect-ration": 2.0
+                        }
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-layout": "vertical",
+                        "card-size": "large",
+                        "category-layout": "grid",
+                        "overlay": true,
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "scope": {
+                "department": "dept1",
+                "_category_title": "Featured One",
+                "cardinality": 10,
+                "id": "featured_1",
+                "local_id": "featured_1_localId",
+                "renderer": {
+                    "components": {
+                        "art": "art",
+                        "subtitle": "subtitle",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-layout": "vertical",
+                        "card-size": "small",
+                        "category-layout": "grid",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "scope": {
+                "_category_title": "featured_2",
+                "cardinality": 10,
+                "id": "featured_2",
+                "local_id": "featured_2_localID",
+                "renderer": {
+                    "components": {
+                        "subtitle": "subtitle",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-layout": "vertical",
+                        "card-size": "medium",
+                        "category-layout": "grid",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "featured": {
+                "id": "featured2",
+                "department": "dept2",
+                "NOT_title": "Featured",
+                "link_to_child": "falseNOT",
+                "pull_from":[
+                    {
+                        "id": "featured_2",
+                        "_title": "Featured: two"
+                    },
+                    {
+                        "id": "com.canonical.scopes.tasks_sctasks",
+                        "_title": "Featured: Tasks"
+                    }
+                ],
+                "renderer_common_id": "news",
+                "NOTrenderer": {
+                    "components": {
+                        "subtitle": "subtitle",
+                        "title": "title",
+                        "art": {
+                            "field": "art",
+                            "aspect-ration": 2.0
+                        }
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-layout": "vertical",
+                        "card-size": "large",
+                        "category-layout": "grid",
+                        "overlay": true,
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "scope": {
+                "department": "dept2",
+                "category_title_use_incoming": "true",
+                "cardinality": 10,
+                "id": "com.canonical.scopes.events_events",
+                "local_id": "events_localID",
+                "renderer": {
+                    "components": {
+                        "art": "art",
+                        "subtitle": "subtitle",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-layout": "horizontal",
+                        "card-size": "small",
+                        "category-layout": "grid",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "scope": {
+                "department": "dept2",
+                "category_title_use_incoming": "true",
+                "cardinality": 10,
+                "id": "com.canonical.scopes.tasks_sctasks",
+                "local_id": "tasks_localID",
+                "renderer": {
+                    "components": {
+                        "art": "art",
+                        "subtitle": "subtitle",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-layout": "horizontal",
+                        "card-size": "small",
+                        "category-layout": "grid",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "scope": {
+                "department": "dept2",
+                "cardinality": 0,
+                "_category_title": "Favorite Contacts",
+                "id": "com.canonical.scopes.contacts_contacts",
+                "local_id": "contacts",
+                "renderer": {
+                    "components": {
+                        "art": "art",
+                        "attributes": "attributes",
+                        "subtitle": "published",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-size": "medium",
+                        "category-layout": "carousel",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "category": {
+                "department": "dept2",
+                "_title": "Today's News",
+                "cardinality": 3,
+                "id": "headlines",
+                "keywords": [
+                    {
+                        "id": "news.headlines",
+                        "local_id": "headlines_categoryKeyword"
+                    }
+                ],
+                "link_to_child_specified": "com.canonical.scopes.news_unity-scope-news",
+                "renderer_common_id": "news",
+                "scopes": []
+            }
+        },
+        {
+            "category": {
+                "department": "dept1",
+                "_title": "Twitter",
+                "cardinality": 10,
+                "id": "twitter",
+                "link_to_child_specified": "twitter.canonicalpartners_twitter",
+                "keywords": [
+                    {
+                        "id": "twitter.home",
+                        "local_id": "twitter.home_localID"
+                    }
+                ],
+                "renderer": {
+                    "components": {
+                        "mascot": "art",
+                        "attributes": "attributes",
+                        "subttitle": "subtitle",
+                        "summary": "summary",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "category-layout": "vertical-journal",
+                        "card-size": "medium",
+                        "card-layout": "horizontal",
+                        "collapsed-rows": 0
+                    }
+                },
+                "scopes": []
+            }
+        },
+        {
+            "featured": {
+                "id": "featured3",
+                "department": "dept3",
+                "NOT_title": "Featured",
+                "link_to_child": "falseNOT",
+                "pull_from":[
+                    {
+                        "id": "notregistered_1",
+                        "_title": "Featured: Not Reg 1"
+                    },
+                    {
+                        "id": "notregistered_2",
+                        "_title": "Featured: Not Reg 2"
+                    },
+                    {
+                        "id": "notregested_3",
+                        "_title": "Featured: Not Reg 3"
+                    }
+                ],
+                "renderer_common_id": "news"
+            }
+        },
+        {
+            "scope": {
+                "department": "dept3",
+                "cardinality": 0,
+                "_category_title": "art",
+                "id": "knitzsche.testscope-art_testscope-art",
+                "local_id": "art",
+                "renderer": {
+                    "components": {
+                        "art": "art",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-size": "medium",
+                        "category-layout": "grid",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "scope": {
+                "department": "dept3",
+                "cardinality": 0,
+                "_category_title": "mascot",
+                "id": "knitzsche.testscope-mascot_testscope-mascot",
+                "local_id": "mascot",
+                "renderer": {
+                    "components": {
+                        "mascot": "mascot",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-size": "medium",
+                        "category-layout": "grid",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        },
+        {
+            "scope": {
+                "department": "dept3",
+                "cardinality": 0,
+                "_category_title": "emblem",
+                "id": "knitzsche.testscope-emblem_testscope-emblem",
+                "local_id": "emblem",
+                "renderer": {
+                    "components": {
+                        "emblem": "emblem",
+                        "title": "title"
+                    },
+                    "schema-version": 1,
+                    "template": {
+                        "card-size": "medium",
+                        "category-layout": "grid",
+                        "collapsed-rows": 1
+                    }
+                }
+            }
+        }
+    ]
+}

=== modified file 'gtests/scope_test.cpp'
--- gtests/scope_test.cpp	2016-09-28 21:01:43 +0000
+++ gtests/scope_test.cpp	2016-11-10 18:47:16 +0000
@@ -210,7 +210,7 @@
     std::string path = scope->scope_directory() + "/" + scope->child_scopes_json_filename();
     ASSERT_TRUE(scope->load_json_file(child_root, path, scope->scope_id())) << "Problem with: " << path;
     scope->set_child_root(child_root);
-    std::vector<std::string> declared_scopes = scope->get_declared_scopes(AggScope::IdType::local_id);
+    std::vector<std::string> declared_scopes = scope->get_declared_scopes();
     ASSERT_EQ(declared_scopes.size(),7) << "csj1.json declares 7 sxscopes, but get_declared_scopes() found " << declared_scopes.size();
 }
 
@@ -365,7 +365,7 @@
     ASSERT_TRUE(scope->load_json_file(child_root, path, scope->scope_id())) << "Problem with: " << path;
     scope->set_child_root(child_root);
     ChildScopeList csl = scope->find_child_scopes();
-    std::vector<std::string> declared_scopes = scope->get_declared_scopes(AggScope::IdType::local_id);
+    std::vector<std::string> declared_scopes = scope->get_declared_scopes();
     ASSERT_EQ(csl.size(),7);
 }
 
@@ -750,3 +750,131 @@
     login_case = q->is_login_case(child, "NOT-login-category");
     ASSERT_FALSE(login_case);
 }
+
+/**
+ * Verify Client::get_current_feeders()
+ * That is, verify that only installed & enabled feeders scopes are returned
+ */
+TEST_F(TestAggScope, featured_verify_get_current_feeders){
+    string csj = "featured_1.json";
+    AggScope * scope_ptr;
+    scope_ptr = &(*scope);
+    scope->set_child_scopes_json_filename(csj);
+    QJsonObject child_root = scope->get_child_root(); 
+    std::string path = scope->scope_directory() + "/" + scope->child_scopes_json_filename();
+    ASSERT_TRUE(scope->load_json_file(child_root, path, scope->scope_id())) << "Problem with: " << path;
+    scope->set_child_root(child_root);
+    SearchMetadata smd("en_US", "phone");
+    CannedQuery cq("not_an_id");
+    shared_ptr<MockRegistry> reg = make_shared<MockRegistry>();
+    Query * q = new Query(cq, smd, string("scope_directory"), string("cache_directory"), reg, scope_ptr); 
+    q->load_declarations(scope_ptr->child_root());
+    q->current_child_scopes = scope->find_child_scopes();
+
+    std::vector<std::string> feeders = {"featured_1", "featured_2"};
+    auto cur = q->client.get_current_feeders(feeders, q->current_child_scopes);
+    ASSERT_EQ(cur.size(), 2); 
+    
+    feeders = {"featured_1", "featured_NOT"};
+    cur = q->client.get_current_feeders(feeders, q->current_child_scopes);
+    ASSERT_EQ(cur.size(), 1); 
+
+    feeders = {"featured_NOT1", "featured_NOT2"};
+    cur = q->client.get_current_feeders(feeders, q->current_child_scopes);
+    ASSERT_EQ(cur.size(), 0); 
+
+    feeders = {"featured_NOT1", "featured_1"};
+    cur = q->client.get_current_feeders(feeders, q->current_child_scopes);
+    ASSERT_EQ(cur.size(), 1); 
+}
+
+/**
+ * Verify Client::get_featured_feeder()
+ * That is, verify that this method returns the NEXT feeder scope (from
+ * which to post the featured  result), including wrapping to the first
+ * feeder when the cache file contains the last one, and that the first
+ * feeder is returned when the existing cache file is removed
+ */
+TEST_F(TestAggScope, featured_verify_get_featured_feeder){
+    string csj = "featured_1.json";
+    AggScope * scope_ptr;
+    scope_ptr = &(*scope);
+    scope->set_child_scopes_json_filename(csj);
+    QJsonObject child_root = scope->get_child_root(); 
+    std::string path = scope->scope_directory() + "/" + scope->child_scopes_json_filename();
+    ASSERT_TRUE(scope->load_json_file(child_root, path, scope->scope_id())) << "Problem with: " << path;
+    scope->set_child_root(child_root);
+    SearchMetadata smd("en_US", "phone");
+    CannedQuery cq("not_an_id");
+    shared_ptr<MockRegistry> reg = make_shared<MockRegistry>();
+    Query * q = new Query(cq, smd, string("scope_directory"), string("cache_directory"), reg, scope_ptr); 
+    q->load_declarations(scope_ptr->child_root());
+    q->current_child_scopes = scope->find_child_scopes();
+    std::vector<std::string> feeders = {"featured_1", "featured_2"};
+    auto cur = q->client.get_current_feeders(feeders, q->current_child_scopes);
+    ASSERT_EQ(cur.size(), 2); 
+    
+    feeders = {"featured_1", "featured_2", "featured_3"};
+    cur = q->client.get_current_feeders(feeders, q->current_child_scopes);
+    ASSERT_EQ(cur.size(),2); // 2 because featured_3 is not registered 
+
+    //clean previous cache file if any 
+    remove(std::string(scope->cache_directory() + "/featured").c_str());
+
+    auto next_feeder = q->client.get_featured_feeder("featured", feeders, scope->cache_directory());
+    ASSERT_EQ(next_feeder, "featured_1");
+    next_feeder = q->client.get_featured_feeder("featured", feeders, scope->cache_directory());
+    ASSERT_EQ(next_feeder, "featured_2");
+    next_feeder = q->client.get_featured_feeder("featured", feeders, scope->cache_directory());
+    ASSERT_EQ(next_feeder, "featured_3");
+    next_feeder = q->client.get_featured_feeder("featured", feeders, scope->cache_directory());
+    ASSERT_EQ(next_feeder, "featured_1");
+
+    next_feeder = q->client.get_featured_feeder("featured", feeders, scope->cache_directory());
+    
+    //remove cache file to verfiy first feeder is returned 
+    remove(std::string(scope->cache_directory() + "/featured").c_str());
+    next_feeder = q->client.get_featured_feeder("featured", feeders, scope->cache_directory());
+    ASSERT_EQ(next_feeder, "featured_1");
+
+}
+
+/**
+ * Verify featured categories exist appropriately
+ */
+TEST_F(TestAggScope, featured_featured_categories_exist){
+    string csj = "featured_1.json";
+    AggScope * scope_ptr;
+    scope_ptr = &(*scope);
+    scope->set_child_scopes_json_filename(csj);
+    QJsonObject child_root = scope->get_child_root(); 
+    std::string path = scope->scope_directory() + "/" + scope->child_scopes_json_filename();
+    ASSERT_TRUE(scope->load_json_file(child_root, path, scope->scope_id())) << "Problem with: " << path;
+    scope->set_child_root(child_root);
+    SearchMetadata smd("en_US", "phone");
+    CannedQuery cq("not_an_id");
+    shared_ptr<MockRegistry> reg = make_shared<MockRegistry>();
+    Query * q = new Query(cq, smd, string("scope_directory"), string("cache_directory"), reg, scope_ptr); 
+    q->load_declarations(scope_ptr->child_root());
+    q->current_child_scopes = scope->find_child_scopes();
+     
+    q->make_featured_scopes();
+    q->set_scope_order();
+    bool featured_1_found = false;
+    bool featured_2_found = false;
+    bool featured_3_found = false;
+    for (auto s : q->scopes_ordered)
+    {
+        if (s == "featured")
+            featured_1_found = true;
+        if (s == "featured2")
+            featured_2_found = true;
+        if (s == "featured3")
+            featured_3_found = true;
+    }
+    ASSERT_TRUE(featured_1_found);
+    ASSERT_TRUE(featured_2_found);
+    ASSERT_FALSE(featured_3_found); // "featured3" IS declared but it has no installed and registered feeder
+}
+
+

=== modified file 'include/aggchildscope.h'
--- include/aggchildscope.h	2016-09-20 17:00:53 +0000
+++ include/aggchildscope.h	2016-11-10 18:47:16 +0000
@@ -46,6 +46,7 @@
     */
     AggChildScope(std::string const & id);
 
+    void set_id(std::string const & id);
     void set_local_id(std::string const & local_id);
     const std::string & local_id() const;
 
@@ -370,6 +371,15 @@
     void set_buffer(bool);
     bool buffer();
 
+    void set_featured_scope(bool);
+    bool featured_scope();
+
+    void set_linked_featured_id(std::string);
+    std::string linked_featured_id();
+
+    void set_featured_feeders(std::vector<std::string> feeders);
+    std::vector<std::string> featured_feeders();
+
     void set_category_scope(bool);
     bool category_scope();
 
@@ -398,6 +408,9 @@
     std::shared_ptr<us::ScopeMetadata> scope_metadata_;
 
     bool buffer_ = true;
+    bool featured_scope_ = false;
+    std::string linked_featured_id_ = "";
+    std::vector<std::string> featured_feeders_; //ids of feeder child scopes
     bool category_scope_ = false;
     std::string category_scope_id_;
     bool keyword_scope_ = false;

=== modified file 'include/client.h'
--- include/client.h	2016-08-19 20:46:32 +0000
+++ include/client.h	2016-11-10 18:47:16 +0000
@@ -21,6 +21,7 @@
 
 #include <unity/UnityExceptions.h>
 #include <unity/scopes/Variant.h>
+#include <unity/scopes/Registry.h>
 
 #include <QDebug>
 #include <QString>
@@ -37,6 +38,8 @@
         int get_cardinality_setting(unity::scopes::VariantMap const& settings, std::vector<int> const& setting_cardinalities);
         QString qstr(std::string const& str) const;
         std::string sstr(QString const& str) const;
+        std::vector<std::string> get_current_feeders(std::vector<std::string> const& feeders_in, unity::scopes::ChildScopeList const& current);
+        std::string get_featured_feeder(std::string const& featured_id, std::vector<std::string> const& feeders, std::string const& cache_dir);
 };
 
 #endif

=== modified file 'include/query.h'
--- include/query.h	2016-09-29 18:42:15 +0000
+++ include/query.h	2016-11-10 18:47:16 +0000
@@ -35,6 +35,16 @@
 
 #include <QJsonObject>
 
+struct featured {
+    std::string id;
+    std::string title; //or use titles (below)
+    std::string dept_id;
+    std::string renderer;
+    bool link_to_child = false;
+    std::vector<std::string> scopes; // id and local_id of feeder scopes
+    std::map<std::string,std::string> titles; //scope id: category title
+};
+
 struct category {
     std::string id;
     std::string title;
@@ -128,6 +138,9 @@
     void handle_category_child(unity::scopes::SearchReplyProxy const& upstream_reply,
                               std::shared_ptr<AggChildScope> scope,
                               unity::scopes::CategorisedResult & res);
+    void handle_featured_child(unity::scopes::SearchReplyProxy const& upstream_reply,
+                              std::shared_ptr<AggChildScope> scope,
+                              unity::scopes::CategorisedResult & res);
     void handle_declared_child(unity::scopes::SearchReplyProxy const& upstream_reply,
                               std::shared_ptr<AggChildScope> scope,
                               unity::scopes::CategorisedResult & res,
@@ -136,15 +149,20 @@
     bool is_login_case(std::shared_ptr<AggChildScope> scope, std::string const& res_cat_id);
     void make_categories();
     void make_declared_scopes();
+    void make_featured_scopes();
     std::vector<std::shared_ptr<category>> categories;
     us::ChildScopeList current_child_scopes;
     std::map<std::string, std::shared_ptr<AggChildScope>> scopes_m;//key is local_id
     bool is_using_departments();
+    void set_scope_order();
+    std::vector<std::string> scopes_ordered;// scope local id or keyword
 
 private:
+    std::vector<std::shared_ptr<featured>> featureds;
+    std::map<std::string,std::map<std::string,std::string>> featured_id_scopeId_title;
+
     bool using_departments = false;
     void make_keyword_scopes();
-    void set_scope_order();
     void display_local_hints_quickstart(us::SearchReplyProxy const& upstream_reply_);
     void display_remote_hints_quickstart(us::SearchReplyProxy const& upstream_reply_);
     bool show_hints(us::SearchReplyProxy const& upstream_reply_);
@@ -182,7 +200,6 @@
     std::vector<std::string> current_scopes;// scope local_id
     std::vector<std::string> current_scopeIds;// keyword cate scope ids to prevent dups
     std::vector<std::string> declared_order;// scope local_id or keyword
-    std::vector<std::string> scopes_ordered;// scope local id or keyword
     /*
     for type_ids_m:
     declared scope:
@@ -196,7 +213,6 @@
         vector: scope ids (vector size varies)
     */
     std::map<std::string,std::vector<std::string>> type_ids_m;// 
-
     std::map<std::string,std::string> localId_id_m;//use scope's local_id to get its fully qualified id
     std::string dept_id_of_root;
     std::string dept_id_of_root_keywords_only;

=== modified file 'include/scope.h'
--- include/scope.h	2016-08-19 20:23:21 +0000
+++ include/scope.h	2016-11-10 18:47:16 +0000
@@ -33,7 +33,6 @@
 class AggScope : public unity::scopes::ScopeBase
 {
 public:
-    enum class IdType {id, local_id};
     AggScope();
     virtual void start(std::string const& scope_name) override;
     virtual void stop() override;
@@ -54,7 +53,7 @@
     void set_child_root(QJsonObject const& root);
     void set_hints_root(QJsonObject const& root);
 
-    std::vector<std::string> get_declared_scopes(IdType) const;
+    std::vector<std::string> get_declared_scopes() const;
     std::vector<std::string> get_declared_keywords() const;
 
     const std::string & scope_id() const;

=== modified file 'src/aggchildscope.cpp'
--- src/aggchildscope.cpp	2016-09-20 17:00:53 +0000
+++ src/aggchildscope.cpp	2016-11-10 18:47:16 +0000
@@ -26,6 +26,12 @@
 {
 }
 
+void AggChildScope::set_id(std::string const &id)
+{
+    id_ = id;
+}
+
+
 void AggChildScope::set_local_id(std::string const &local_id)
 {
     local_id_ = local_id;
@@ -289,6 +295,37 @@
     return buffer_;
 }
 
+void AggChildScope::set_featured_scope(bool b)
+{
+    featured_scope_ = b;
+}
+
+bool AggChildScope::featured_scope()
+{
+    return featured_scope_;
+}
+
+void AggChildScope::set_linked_featured_id(std::string id)
+{
+    linked_featured_id_ = id;
+}
+
+std::string AggChildScope::linked_featured_id()
+{
+    return linked_featured_id_;
+}
+
+void AggChildScope::set_featured_feeders(std::vector<std::string> feeders)
+{
+    featured_feeders_ = feeders;
+}
+
+std::vector<std::string> AggChildScope::featured_feeders()
+{
+    return featured_feeders_;
+}
+
+
 void AggChildScope::set_category_scope(bool b)
 {
     category_scope_ = b;

=== modified file 'src/client.cpp'
--- src/client.cpp	2016-08-19 20:46:32 +0000
+++ src/client.cpp	2016-11-10 18:47:16 +0000
@@ -19,6 +19,10 @@
 #include "client.h"
 #include <unity-scopes.h>
 
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QDebug>
@@ -92,3 +96,87 @@
 {
     return QString::fromStdString(str);
 }
+
+/**
+ * Get the feeder scope IDs that are installed and enabled
+ */
+std::vector<std::string> Client::get_current_feeders(std::vector<std::string> const& feeders_in, us::ChildScopeList const& current_child_scopes)
+{
+
+    std::vector<std::string> feeders;
+	// remove scopes that are not current
+	for (std::string const& f : feeders_in)
+	{
+		for (auto const& ascope : current_child_scopes)
+		{
+			if (ascope.id != f)
+			{
+				continue;
+			}
+			if (ascope.enabled)
+			{
+				feeders.emplace_back(ascope.id);
+			}
+		}
+	}
+ return feeders;
+
+}
+
+/**
+ * Get the scope id of the the next scope id to display in the featured category
+ * where we cycle through feeders scopes using the scope in the cache file to find the next.
+ * If cache file does not exists or has any other problem, use the first feeder scope.
+ * In all cases, truncate the cache file and write it with the new & current scope id.
+ */
+std::string Client::get_featured_feeder(std::string const& featured_id, std::vector<std::string> const& feeders, std::string const& cache_dir)
+{
+
+    std::string feeder;
+    std::string fpath = cache_dir + "/" + featured_id;
+    //if cache file does not exist, no previous, so use first
+    std::ifstream f(fpath);
+    if (f.good())
+    {
+        std::stringstream previous_stream;
+        std::string previous;
+        previous_stream << f.rdbuf();
+        previous = previous_stream.str();
+        std::vector<std::string>::const_iterator iter;
+        unsigned int idx = 0;
+        bool using_cached = true;
+        for (iter = feeders.begin() ; iter < feeders.end() ; iter++,idx++)
+        {
+            if (*iter == previous || !using_cached)
+            {
+
+                if (idx == feeders.size()-1)
+                {
+                    feeder = feeders[0];
+                }
+                else
+                {
+                    feeder = feeders[idx+1];
+                } 
+				break;
+            }
+        }
+    } 
+    if (feeder.empty())
+    {
+        feeder = feeders[0];
+    }
+    //write current feeder scope id to cache file
+    try
+    {
+        std::ofstream f2;
+        f2.open (fpath, std::ios::trunc);
+        f2 << feeder;
+        f2.close();
+    }
+    catch (const std::exception& e)
+    {
+        qDebug() <<"=== FEATURED. can't write cache file: " << QString::fromStdString(fpath);
+    }
+    return feeder;
+}

=== modified file 'src/handle_results.cpp'
--- src/handle_results.cpp	2016-09-29 18:42:15 +0000
+++ src/handle_results.cpp	2016-11-10 18:47:16 +0000
@@ -759,7 +759,7 @@
     bool login_case = is_login_case(scope, res.category()->id());
     qDebug() << "==== DECLARED. login_case: " << QString::number(login_case); 
     bool link = scope->category_link_to_child();//this means the category links, not that we get a specific child scope's category
-    std:: string link_to = scope->id();
+    std::string link_to = scope->id();
     bool has_rdr = !scope->surface_template().empty();
 
     // Determine the current case based on state
@@ -958,3 +958,115 @@
     }
 
 }
+
+void Query::handle_featured_child(unity::scopes::SearchReplyProxy const& upstream_reply,
+                                 std::shared_ptr<AggChildScope> scope,
+                                 us::CategorisedResult & res ){
+
+    //the supported cases
+    enum RunType {
+                    Surface,
+                    SurfaceNoRdr,
+                    SurfaceNoLink,
+                    SurfaceNoLinkNoRdr
+                  };
+    RunType runType;        
+
+    //get state
+    qDebug() << "==== handle FEATURED";
+    bool link = scope->category_link_to_child();//this means the category links, not that we get a specific child scope's category
+    qDebug() << "==== handle FEATURED. link: " << QString::number(link);
+    std:: string link_to = scope->id();
+    bool has_rdr = !scope->surface_template().empty();
+
+    qDebug() << "==== handle FEATUREDi. link_to:" << client.qstr(link_to);
+
+    // Determine the current case based on state
+    if (!query().query_string().empty())
+    {
+        //do nothing
+    }
+    else
+    {//surface
+        if (link)
+        {
+            if (has_rdr)
+            {
+                runType = Surface;
+            }
+            else
+            {
+                runType = SurfaceNoRdr;
+            }
+        }
+        else
+        { // no link
+            if (has_rdr)
+            {
+                runType = SurfaceNoLink;
+            }
+            else
+            {
+                runType = SurfaceNoLinkNoRdr;
+            }
+        }
+    }
+
+    // for use in category registration
+    std::string cat_id;
+    std::string cat_title;
+    std::string rdr;
+
+    if (!scope->category_title().empty())
+    {
+        cat_title = scope->category_title();
+    }
+    else //uses per scope category title declarations
+    {
+        cat_title = featured_id_scopeId_title[scope->local_id()][scope->id()];
+    }
+
+    switch (runType)
+    {
+         case RunType::Surface:
+            qDebug() << "=== run type: featured scope Surface";
+            cat_id = scope->local_id() + ":featured:surface";
+            rdr = scope->surface_template();
+            set_result_catgory(upstream_reply, res, cat_id, cat_title, rdr, link_to);
+            break;
+        case RunType::SurfaceNoRdr:
+            qDebug() << "=== run type: featured scope SurfaceNoRdr";
+            cat_id = scope->local_id() + ":featured:no-rdr:surface";
+            rdr = res.category()->renderer_template().data();
+            set_result_catgory(upstream_reply, res, cat_id, cat_title, rdr, link_to);
+            break;
+        case RunType::SurfaceNoLink:
+            qDebug() << "=== run type: featured scope SurfaceNoLink";
+            cat_id = scope->local_id() + ":featuredr:no-link:surface";
+            rdr = scope->surface_template();
+            set_result_catgory(upstream_reply, res, cat_id, cat_title, rdr);
+            break;
+        case RunType::SurfaceNoLinkNoRdr:
+            qDebug() << "=== run type: featured scope SurfaceNoLinkNoRdr";
+            cat_id = scope->local_id() + ":featured:no-link:no-rdr:surface";
+            rdr = res.category()->renderer_template().data();
+            set_result_catgory(upstream_reply, res, cat_id, cat_title, rdr);
+            break;
+    }
+
+    //TODO: put FALLBACK into method to avoid duplication needed by refactor
+    // perform res component fallback, as needed
+    if(!scope->surface_common_template_id().empty())
+    {
+        std::string res_str = us::Variant(res.serialize()).serialize_json(); 
+        auto change = this->client.check_result_fallbacks(res_str,
+                                                          scope->surface_common_template_id(),
+                                                          this->get_common_templates_fallbacks());
+        if (!std::get<0>(change).empty())
+        {
+            res[std::get<0>(change)] = std::get<1>(change);
+            qDebug() << "=== FEATURED handle. fallback change field:" << client.qstr(std::get<0>(change));
+            qDebug() << "=== FEATURED handle. fallback change value:" << client.qstr(std::get<1>(change));
+        }
+    }
+}

=== modified file 'src/query.cpp'
--- src/query.cpp	2016-09-29 18:42:15 +0000
+++ src/query.cpp	2016-11-10 18:47:16 +0000
@@ -311,6 +311,10 @@
 
     // create child scope instances from keywords and scopes
     make_categories();
+    
+    // create child scope instances from featureds, only when not searching
+    if (empty_search)
+        make_featured_scopes();
 
     // complete initializations including cutting child scopes to those present and enabled
     complete_child_scopes();
@@ -554,6 +558,11 @@
             {
                 handle_category_child(upstream_reply, scope, res);
             }
+            else if (scope->featured_scope())
+            {
+                qDebug() << "==== handle_ is FEATURED scope: " << client.qstr(scope->id());
+                handle_featured_child(upstream_reply, scope, res);
+            }
             else // is a declared scope
             {
                 handle_declared_child(upstream_reply, scope, res, inc_res_cat_id, inc_res_cat_title);

=== modified file 'src/scope.cpp'
--- src/scope.cpp	2016-08-19 20:23:21 +0000
+++ src/scope.cpp	2016-11-10 18:47:16 +0000
@@ -27,10 +27,7 @@
 #include <sstream>
 #include <unity-scopes.h>
 
-
 #include <QDebug>
-#include <QFile>
-#include <QFile>
 #include <QJsonParseError>
 #include <QJsonDocument>
 #include <QJsonObject>
@@ -158,7 +155,7 @@
     return preview;
 }
 
-std::vector<std::string> AggScope::get_declared_scopes(IdType type) const
+std::vector<std::string> AggScope::get_declared_scopes() const
 {
     std::vector<std::string> declared_scopes;
 
@@ -171,16 +168,8 @@
         if (item_o.contains(QStringLiteral("scope")))
         {
             QJsonObject scope_o = item_o[QStringLiteral("scope")].toObject();
-            if (type == IdType::local_id)
-            {
-                std::string local_id = scope_o[QStringLiteral("local_id")].toString().toStdString();
-                declared_scopes.emplace_back(local_id);
-            }
-            else
-            {
-                std::string id = scope_o[QStringLiteral("id")].toString().toStdString();
-                declared_scopes.emplace_back(id);
-            }
+            std::string id = scope_o[QStringLiteral("id")].toString().toStdString();
+            declared_scopes.emplace_back(id);
         }
         else if (item_o.contains(QStringLiteral("category")))
         {
@@ -191,16 +180,8 @@
                 for (const auto &item : scopes_a)
                 {
                     QJsonObject scope_o = item.toObject();
-                    if (type == IdType::local_id)
-                    {
-                        std::string local_id = scope_o[QStringLiteral("local_id")].toString().toStdString();
-                        declared_scopes.emplace_back(local_id);
-                    }
-                    else
-                    {
-                        std::string id = scope_o[QStringLiteral("id")].toString().toStdString();
-                        declared_scopes.emplace_back(id);
-                    }
+                    std::string id = scope_o[QStringLiteral("id")].toString().toStdString();
+                    declared_scopes.emplace_back(id);
                 }
             }
         }
@@ -249,7 +230,7 @@
 
 us::ChildScopeList AggScope::find_child_scopes() const
 {
-    std::vector<std::string> declared_scopes = get_declared_scopes(IdType::id);
+    std::vector<std::string> declared_scopes = get_declared_scopes();
 
     us::ChildScopeList list;
     std::map<std::string,us::ScopeMetadata> declared_registered_scopes;

=== modified file 'src/utils.cpp'
--- src/utils.cpp	2016-09-28 21:01:43 +0000
+++ src/utils.cpp	2016-11-10 18:47:16 +0000
@@ -140,8 +140,52 @@
     for (const auto & item_o_ : order_a)
     {
         QJsonObject item_o = item_o_.toObject();
-
-        if (item_o.contains(QStringLiteral("category")))
+        if (item_o.contains(QStringLiteral("featured")))
+        {
+            qDebug() << "=== FEATURED. load json";
+            QJsonObject featured_o = item_o[QStringLiteral("featured")].toObject();
+            std::shared_ptr<featured> featured_ptr = std::make_shared<featured>();
+            featured_ptr->id = featured_o[QStringLiteral("id")].toString().toStdString();
+            declared_order.emplace_back(featured_ptr->id);
+            if (featured_o.contains(QStringLiteral("department")))
+            {
+                featured_ptr->dept_id = featured_o[QStringLiteral("department")].toString().toStdString();
+            }
+            featured_ptr->link_to_child = true;
+            if (featured_o.contains(QStringLiteral("link_to_child")))
+            {
+                if (featured_o[QStringLiteral("link_to_child")].toString() == FALSE)
+                    featured_ptr->link_to_child = false;
+            }
+            if (featured_o.contains(QStringLiteral("renderer_common_id")))
+            {
+                std::string id = featured_o[QStringLiteral("renderer_common_id")].toString().toStdString();
+                featured_ptr->renderer = common_templates[id];
+                categoryId_surfaceRdrs_catId2commonId[featured_ptr->id] = id;
+            }
+            else
+            {
+                QJsonObject renderer_o = featured_o[QStringLiteral("renderer")].toObject();
+                QJsonDocument st_d(renderer_o);
+                featured_ptr->renderer = client.sstr(st_d.toJson());
+            }
+            QJsonArray scope_a = featured_o[QStringLiteral("pull_from")].toArray();
+            for (const auto item : scope_a)
+            {
+                QJsonObject scope_o = item.toObject();
+                featured_ptr->scopes.emplace_back(scope_o[QStringLiteral("id")].toString().toStdString());
+                if (scope_o.contains(QStringLiteral("_title")))
+                {
+                    featured_ptr->titles[scope_o[QStringLiteral("id")].toString().toStdString()] = _(scope_o[QStringLiteral("_title")].toString().toStdString().c_str());
+                }
+            } 
+            if (featured_o.contains(QStringLiteral("_title")))
+            {
+                featured_ptr->title = featured_o[QStringLiteral("_title")].toString().toStdString();
+            }
+            featureds.emplace_back(featured_ptr);
+        }
+        else if (item_o.contains(QStringLiteral("category")))
         {
             QJsonObject cat_o = item_o[QStringLiteral("category")].toObject();
             std::shared_ptr<category> cat_ptr = std::make_shared<category>();
@@ -621,7 +665,7 @@
 {
     for (std::string id : declared_order)
     {
-        //qDebug() << "==== SET ORDER. DECLARED order id: " << client.qstr(id);
+       qDebug() << "==== SET ORDER. DECLARED order id: " << client.qstr(id);
         for (const auto & pr : type_ids_m)
         {
             if (pr.first == id)
@@ -674,7 +718,6 @@
                                 unorder_keyscopes.emplace_back(scope_id);
                             }
                         }
-
                         scopes_ordered.insert(scopes_ordered.end(), order_keyscopes.begin(), order_keyscopes.end());
                         scopes_ordered.insert(scopes_ordered.end(), unorder_keyscopes.begin(), unorder_keyscopes.end());
                     }
@@ -696,11 +739,70 @@
     }
 }
 
+void Query::make_featured_scopes()
+{
+    for (std::shared_ptr<featured> featured : featureds)
+    {
+        auto f_ptr = std::make_shared<AggChildScope>("temporary_id");
+        std::vector<std::string> feeders;
+        for (auto feeder : featured->scopes)
+        {
+            feeders.emplace_back(feeder);
+        }
+        if (feeders.size() == 0 )
+        {
+            continue;//this is a  json config mistake
+        }
+
+        f_ptr->set_featured_feeders(client.get_current_feeders(feeders, current_child_scopes));
+        
+        if (f_ptr->featured_feeders().size() == 0)
+        {
+            continue;//none of the featured feeders are installed and enabled
+        }
+        f_ptr->set_id(client.get_featured_feeder(featured->id, f_ptr->featured_feeders(), cache_dir_));
+        f_ptr->set_local_id(featured->id);
+        f_ptr->set_featured_scope(true);
+        f_ptr->set_cardinality(1);
+
+        if (!featured->title.empty())
+        {
+            f_ptr->set_category_title(_(featured->title.c_str()));
+        }
+        else if (featured->titles.size() > 0)
+        {//using per feeder scope category titles
+            std::map<std::string,std::string>::iterator iter;
+            for (iter = featured->titles.begin(); iter != featured->titles.end(); iter++)
+            {
+               featured_id_scopeId_title[featured->id][iter->first] = iter->second; 
+            }
+        }
+        if (using_departments)
+        {
+            f_ptr->set_department(featured->dept_id);
+        }
+        f_ptr->set_surface_template(featured->renderer);
+
+        if (categoryId_surfaceRdrs_catId2commonId.find(featured->id) != categoryId_surfaceRdrs_catId2commonId.end())
+        {
+            f_ptr->set_surface_common_template_id(categoryId_surfaceRdrs_catId2commonId[featured->id]);
+        }
+        f_ptr->set_category_link_to_child(featured->link_to_child);
+
+        type_ids_m[f_ptr->local_id()].emplace_back(f_ptr->local_id());
+        localId_id_m[f_ptr->local_id()] = f_ptr->id();
+        scopes_m[f_ptr->local_id()] = f_ptr;
+        current_scopes.emplace_back(f_ptr->local_id());
+        qWarning () << QString("%1: ADDING FEATURED scope: %2")
+            .arg(client.qstr(agg_scope_->scope_id()), client.qstr(f_ptr->id()));
+    }
+}
+
+
 /*
  * makes the AggChildScope instances using values and options
  * declared in json, else default values from child_scope struct
  */
-
 void Query::make_declared_scopes()
 {
     //iterate declared child scopes