← Back to branch summary

~mvo/software-center/trivial-renaming

« back to all changes in this revision

Viewing changes to softwarecenter/ui/gtk3/widgets/recommendations.py

  • Committer: Gary Lasker
  • Date: 2012-09-06 17:25:40 UTC
  • mfrom: (3083.3.24 software-center)
  • Revision ID: gary.lasker@canonical.com-20120906172540-m07wdwkad9jjkbp5
merge recommender feedback feature branch lp:~gary-lasker/software-center/recommended-installed-feedback after approval by mvo and FFe approval (LP: #944060, LP: #1044107)

Show diffs side-by-side

added added

removed removed

Lines of Context:
softwarecenter/ui/gtk3/widgets/recommendations.py
24
24
 
25
25
from softwarecenter.ui.gtk3.em import StockEms
26
26
from softwarecenter.ui.gtk3.widgets.containers import (FramedHeaderBox,
27
 
                                                       FlowableGrid)
 
27
                                                       TileGrid)
28
28
from softwarecenter.ui.gtk3.utils import get_parent_xid
29
29
from softwarecenter.db.categories import (RecommendedForYouCategory,
30
30
                                          AppRecommendationsCategory)
 
31
from softwarecenter.backend import get_install_backend
31
32
from softwarecenter.backend.recagent import RecommenderAgent
32
33
from softwarecenter.backend.login_sso import get_sso_backend
33
34
from softwarecenter.backend.ubuntusso import get_ubuntu_sso_backend
35
36
    LOBBY_RECOMMENDATIONS_CAROUSEL_LIMIT,
36
37
    DETAILS_RECOMMENDATIONS_CAROUSEL_LIMIT,
37
38
    SOFTWARE_CENTER_NAME_KEYRING,
 
39
    RecommenderFeedbackActions,
 
40
    TransactionTypes,
38
41
    )
39
42
from softwarecenter.utils import utf8
40
43
from softwarecenter.netstatus import network_state_is_connected
54
57
                                 ),
55
58
        }
56
59
 
57
 
    def __init__(self, catview):
 
60
    def __init__(self):
58
61
        FramedHeaderBox.__init__(self)
59
 
        # FIXME: we only need the catview for "add_titles_to_flowgrid"
60
 
        #        and "on_category_clicked" so we should be able to
61
 
        #        extract this to a "leaner" widget
62
 
        self.catview = catview
63
 
        self.catview.connect(
64
 
                    "application-activated", self._on_application_activated)
65
62
        self.recommender_agent = RecommenderAgent()
 
63
        # keep track of applications that have been viewed via a
 
64
        # recommendation so that we can detect when a recommended app
 
65
        # has been installed
 
66
        self.recommended_apps_viewed = set()
 
67
        self.backend = get_install_backend()
 
68
        self.backend.connect("transaction-started",
 
69
                             self._on_transaction_started)
 
70
        self.backend.connect("transaction-finished",
 
71
                             self._on_transaction_finished)
66
72
 
67
 
    def _on_application_activated(self, catview, app):
 
73
    def _on_application_activated(self, tile, app):
68
74
        self.emit("application-activated", app)
 
75
        # we only track installed items if the user has opted-in to the
 
76
        # recommendations service
 
77
        if self.recommender_agent.is_opted_in():
 
78
            self.recommended_apps_viewed.add(app.pkgname)
 
79
 
 
80
    def _on_transaction_started(self, backend, pkgname, appname, trans_id,
 
81
                                trans_type):
 
82
        if (trans_type != TransactionTypes.INSTALL and
 
83
            pkgname in self.recommended_apps_viewed):
 
84
            # if the transaction is not an installation we don't want to
 
85
            # track it as a recommended item
 
86
            self.recommended_apps_viewed.remove(pkgname)
 
87
 
 
88
    def _on_transaction_finished(self, backend, result):
 
89
        if result.pkgname in self.recommended_apps_viewed:
 
90
            self.recommended_apps_viewed.remove(result.pkgname)
 
91
            if network_state_is_connected():
 
92
                # no need to monitor for an error, etc., for this
 
93
                self.recommender_agent.post_implicit_feedback(
 
94
                        result.pkgname,
 
95
                        RecommenderFeedbackActions.INSTALLED)
69
96
 
70
97
    def _on_recommender_agent_error(self, agent, msg):
71
98
        LOG.warn("Error while accessing the recommender agent: %s" % msg)
81
108
    Panel for use in the category view that displays recommended apps for
82
109
    the given category
83
110
    """
84
 
    def __init__(self, catview, subcategory):
85
 
        RecommendationsPanel.__init__(self, catview)
 
111
 
 
112
    __gsignals__ = {
 
113
        "more-button-clicked": (GObject.SignalFlags.RUN_LAST,
 
114
                                None,
 
115
                                (GObject.TYPE_PYOBJECT, ),
 
116
                               ),
 
117
        }
 
118
 
 
119
    def __init__(self, db, properties_helper, subcategory):
 
120
        RecommendationsPanel.__init__(self)
 
121
        self.db = db
 
122
        self.properties_helper = properties_helper
86
123
        self.subcategory = subcategory
87
124
        if self.subcategory:
88
125
            self.set_header_label(GObject.markup_escape_text(utf8(
98
135
        if self.recommended_for_you_content:
99
136
            self.recommended_for_you_content.destroy()
100
137
        # add the new stuff
101
 
        self.recommended_for_you_content = FlowableGrid()
 
138
        self.recommended_for_you_content = TileGrid()
 
139
        self.recommended_for_you_content.connect(
 
140
                    "application-activated", self._on_application_activated)
102
141
        self.add(self.recommended_for_you_content)
103
142
        self.spinner_notebook.show_spinner(_(u"Receiving recommendations…"))
104
143
        # get the recommendations from the recommender agent
112
151
 
113
152
    def _on_recommended_for_you_agent_refresh(self, cat):
114
153
        self.header_implements_more_button()
115
 
        docs = cat.get_documents(self.catview.db)
 
154
        self.more.connect("clicked",
 
155
                          self._on_more_button_clicked,
 
156
                          self.recommended_for_you_cat)
 
157
        docs = cat.get_documents(self.db)
116
158
        # display the recommendedations
117
159
        if len(docs) > 0:
118
 
            self.catview._add_tiles_to_flowgrid(
119
 
                docs, self.recommended_for_you_content,
120
 
                LOBBY_RECOMMENDATIONS_CAROUSEL_LIMIT)
 
160
            self.recommended_for_you_content.add_tiles(
 
161
                    self.properties_helper,
 
162
                    docs,
 
163
                    LOBBY_RECOMMENDATIONS_CAROUSEL_LIMIT)
121
164
            self.recommended_for_you_content.show_all()
122
165
            self.spinner_notebook.hide_spinner()
123
 
            self.more.connect('clicked',
124
 
                              self.catview.on_category_clicked,
125
 
                              cat)
126
166
            self.header.queue_draw()
127
167
            self.show_all()
128
168
        else:
129
169
            # hide the panel if we have no recommendations to show
130
170
            self.hide()
131
171
 
 
172
    def _on_more_button_clicked(self, btn, category):
 
173
        self.emit("more-button-clicked", category)
 
174
 
132
175
 
133
176
class RecommendationsPanelLobby(RecommendationsPanelCategory):
134
177
    """
155
198
    NO_NETWORK_RECOMMENDATIONS_TEXT = _(u"Recommendations will appear "
156
199
                                         "when next online.")
157
200
 
158
 
    def __init__(self, catview):
159
 
        RecommendationsPanel.__init__(self, catview)
 
201
    def __init__(self, db, properties_helper):
 
202
        RecommendationsPanel.__init__(self)
 
203
        self.db = db
 
204
        self.properties_helper = properties_helper
160
205
        self.subcategory = None
161
206
        self.set_header_label(_(u"Recommended For You"))
162
207
        self.recommended_for_you_content = None
325
370
                                  self._on_profile_submitted)
326
371
        self.recommender_agent.connect("error",
327
372
                                  self._on_profile_submitted_error)
328
 
        self.recommender_agent.post_submit_profile(self.catview.db)
 
373
        self.recommender_agent.post_submit_profile(self.db)
329
374
 
330
375
    def _on_profile_submitted(self, agent, profile):
331
376
        # after the user profile data has been uploaded, make the request
362
407
    Panel for use in the details view to display recommendations for a given
363
408
    application
364
409
    """
365
 
    def __init__(self, catview):
366
 
        RecommendationsPanel.__init__(self, catview)
 
410
    def __init__(self, db, properties_helper):
 
411
        RecommendationsPanel.__init__(self)
 
412
        self.db = db
 
413
        self.properties_helper = properties_helper
367
414
        self.set_header_label(_(u"People Also Installed"))
368
 
        self.app_recommendations_content = FlowableGrid()
 
415
        self.app_recommendations_content = TileGrid()
 
416
        self.app_recommendations_content.connect(
 
417
                    "application-activated", self._on_application_activated)
369
418
        self.add(self.app_recommendations_content)
370
419
 
371
420
    def set_pkgname(self, pkgname):
385
434
                                             self._on_recommender_agent_error)
386
435
 
387
436
    def _on_app_recommendations_agent_refresh(self, cat):
388
 
        docs = cat.get_documents(self.catview.db)
 
437
        docs = cat.get_documents(self.db)
389
438
        # display the recommendations
390
439
        if len(docs) > 0:
391
 
            self.catview._add_tiles_to_flowgrid(
392
 
                docs, self.app_recommendations_content,
393
 
                DETAILS_RECOMMENDATIONS_CAROUSEL_LIMIT)
 
440
            self.app_recommendations_content.add_tiles(
 
441
                    self.properties_helper,
 
442
                    docs,
 
443
                    DETAILS_RECOMMENDATIONS_CAROUSEL_LIMIT)
394
444
            self.show_all()
395
445
            self.spinner_notebook.hide_spinner()
396
446
        else: