def restore(cls):
session_data = session.get(cls.session_key)
if session_data is None:
return None
else:
return ECommerceOrder.get_instance(session_data)
def _get_edit_stack(self, stack_id, preserved_stacks=None):
edit_stack = self.__stack_map.get(stack_id)
if edit_stack is None:
if preserved_stacks is None:
preserved_stacks = session.get(self._session_key)
if preserved_stacks:
entry = preserved_stacks.get(stack_id)
if entry is None:
raise WrongEditStackError(stack_id)
last_update, stack_data = entry
if self.expiration is not None:
preserved_stacks[stack_id] = (datetime.now(), stack_data)
edit_stack = self._loads(stack_data)
self.__stack_map[stack_id] = edit_stack
self._remove_expired_edit_stacks(preserved_stacks)
return edit_stack
def pop_user_notifications(filter=None):
"""Retrieves pending notification messages that were stored through the
L{notify_user} method.
Retrieved messages are considered to be consumed, and therefore they
are removed from the list of pending notifications.
@param filter: If given, only those notifications matching the specified
criteria will be retrieved. The criteria matches as follows:
* If set to a string, it designates a single notification category
to retrieve.
* If set to a sequence (list, tuple, set), it designates a set of
categories; notifications belonging to any of the specified
categories will be retrieved.
* If set to a callable, it will be used as filter function, taking
a notification tuple as its single parameter, and returning True
if the notification is to be retrieved, or False if it should be
ignored.
@return: The sequence of pending notification messages. Each message
consists of a tuple with the message text, its category and wether
or not it should be treated as a transient message.
@rtype: sequence of (tuple of (unicode, unicode or None, bool))
"""
notifications = session.get("notifications")
if notifications is None:
return []
remaining = []
if filter:
matching = []
if isinstance(filter, basestring):
match = lambda notification: notification[1] == filter
elif callable(filter):
match = filter
elif hasattr("__contains__", filter):
match = lambda notification: notification[1] in filter
else:
raise TypeError(
"The 'filter' parameter for the pop_user_notifications() "
"function should be a string, a sequence or callable, got "
"%s instead" % type(filter))
for notification in notifications:
(matching
if match(notification) else remaining).append(notification)
notifications = matching
session["notifications"] = remaining
return notifications
def create_edit_stack(self):
"""Creates a new edit stack.
@return: The new edit stack.
@rtype: L{EditStack}
"""
edit_stack = resolve(self._edit_stack_class)()
edit_stack.id = session.get(self._session_id_key, 0)
edit_stack.root_url = cherrypy.request.params.get("root_url")
session[self._session_id_key] = edit_stack.id + 1
self.__stack_map[edit_stack.id] = edit_stack
self._remove_expired_edit_stacks()
return edit_stack
def edit_stacks(self):
"""Obtains a mapping containing all the edit stacks for the current
browsing session.
@return: The mapping of stacks, indexed by their numerical id.
@rtype: mapping of int => L{EditStack}
"""
preserved_stacks = session.get(self._session_key)
edit_stacks = {}
if preserved_stacks:
for id, entry in preserved_stacks.iteritems():
stack = self._get_edit_stack(id)
edit_stacks[id] = stack
return DictWrapper(edit_stacks)
def preserve_edit_stack(self, edit_stack):
"""Stores changes to the given edit stack inside the current HTTP
session, so it can be retrieved by later requests.
@param edit_stack: The edit stack to preserve.
@type edit_stack: L{EditStack}
"""
preserved_stacks = session.get(self._session_key)
if preserved_stacks is None:
preserved_stacks = {}
session[self._session_key] = preserved_stacks
preserved_stacks[edit_stack.id] = (datetime.now(),
self._dumps(edit_stack))
session.save()
def step2(self):
credentials = session.get(SESSION_PREFIX + "credentials")
if not credentials or credentials.access_token_expired:
redirect(self.step_url(1))
http_auth = credentials.authorize(httplib2.Http())
oauth2_service = discovery.build('oauth2', 'v2', http_auth)
user_data = oauth2_service.userinfo().get().execute()
if self.provider.debug_mode:
print(styled("Google user profile:", "magenta"), user_data)
self.provider.login(user_data)
del session[SESSION_PREFIX + "credentials"]
redirect(self.target_url)
def _remove_expired_edit_stacks(self,
preserved_stacks=None,
current_time=None):
if self.expiration is None:
return
if preserved_stacks is None:
preserved_stacks = session.get(self._session_key)
if preserved_stacks is None:
return
if current_time is None:
current_time = datetime.now()
for stack_id, (last_update, stack_data) in preserved_stacks.items():
if (current_time - last_update).seconds >= self.expiration:
del preserved_stacks[stack_id]
session.save()
def step2(self):
credentials = session.get(SESSION_PREFIX + "credentials")
if not credentials:
redirect(self.step_url(1))
fields = ['name', 'email']
query = '{}{}{}{}'.format(
'https://graph.facebook.com', '/me?', 'fields=' + ','.join(fields),
'&access_token=' + credentials['access_token'])
user_data_file = urllib.request.urlopen(query).readline()
user_data = json.loads(user_data_file)
self.check_step2_errors(user_data)
if self.provider.debug_mode:
print(styled("Facebook user profile:", "magenta"), user_data)
self.provider.login(user_data)
del session[SESSION_PREFIX + "credentials"]
redirect(self.target_url)
def notify_user(message, category=None, transient=True):
"""Creates a new notification for the current user.
Notifications are stored until a proper page is served to the user. It
is up to the views to decide how these messages should be displayed.
@param message: The message that will be shown to the user.
@type message: unicode
@param category: An optional free form string identifier that qualifies
the message. Standard values include 'success' and 'error'.
@type category: unicode
@param transient: Indicates if the message should be hidden after a
short lapse (True), or if it should remain visible until explicitly
closed by the user (False).
@type transient: bool
"""
notifications = session.get("notifications")
if notifications is None:
session["notifications"] = notifications = []
notifications.append((message, category, transient))
def get_user_from_session(self):
session_user_id = session.get(self.SESSION_KEY)
if session_user_id:
return User.get_instance(session_user_id)
def __init__(self, provider):
Controller.__init__(self)
self.provider = provider
self.target_url = (session.get(SESSION_PREFIX + "target_url")
or app.website.home.get_uri())
def get_block_clipboard_contents():
return session.get(BLOCK_CLIPBOARD_SESSION_KEY)
def catalog_current_state_uri():
state = session.get(SESSION_KEY) or {}
catalog = Publishable.require_instance(
qname="woost.extensions.ecommerce.catalog_page")
return catalog.get_uri(parameters=state)
