def handle_exception_raised(cls, event): # Redirect the user to the backoffice root when failing to load an edit # stack node if isinstance(event.exception, WrongEditStackError): notify_user(translations(event.exception), "error") raise cherrypy.HTTPRedirect(event.source.contextual_uri())
def handle_exception_raised(event): if isinstance( event.exception, RunningMailingError ): notify_user(translations(event.exception), "error") raise cherrypy.HTTPRedirect(event.source.contextual_uri())
def submit(self): # TODO: cycle prevention # TODO: support for inserting before a sibling # TODO: dropping objects on objects (inferring/asking the target member) @transactional() def relate(): dragged_object = self.dragged_object target_object = self.target_object target_member = self.target_member user = get_current_user() user.require_permission(ModifyPermission, target=dragged_object) user.require_permission(ModifyPermission, target=target_object) with changeset_context(user): if isinstance(target_member, schema.Reference): target_object.set(target_member, dragged_object) else: collection = target_object.get(target_member) sibling = self.sibling relative_placement = self.relative_placement if sibling: try: current_index = collection.index(dragged_object) except ValueError: current_index = None index = collection.index(sibling) if relative_placement == "before": if current_index is not None and current_index < index: index -= 1 elif relative_placement == "after": if current_index is None or current_index >= index: index += 1 if isinstance(collection, (OrderedSet, InstrumentedOrderedSet)): kwargs = {"relocate": True} else: kwargs = {} collection.insert(index, dragged_object, **kwargs) else: collection.append(dragged_object) relate() notify_user(translations( "woost.controllers.backoffice.DragAndDropController" ".drop_notification", dragged_object=self.dragged_object, target_object=self.target_object, target_member=self.target_member), "success", transient=False)
def submit(self): Basket.empty() notify_user( translations("woost.extensions.ecommerce." "empty_basket_notice"), category = "success" ) Location.get_current().go("GET")
def item_saved_notification(self, is_new, change): if change and "enabled" in change.changed_members: notify_user( translations("woost.controllers.backoffice.ExtensionEditNode " "%s extension needs reloading" % ("enabled" if self.item.enabled else "disabled"), extension=self.item), "notice", transient=False) else: EditNode.item_saved_notification(self, is_new, change)
def invoke(self, controller, selection): if selection is None: app.cache.clear() else: for item in selection: item.clear_cache() notify_user( translations("woost.cache_invalidated_notice", subset = selection), "success" )
def handle_committed(cls, event): item = event.source.item try: item.update() except Exception, e: notify_user(translations( "woost.extensions.campaignmonitorlisteditnode.CampaignMonitorListEditNode failed synchronization", item=item, exception=e), "error", transient=False)
def invoke(self, controller, selection): target = selection[0] consumer = Consumer(target.app_id, target.app_secret) def request(client, *args, **kwargs): response, body = client.request(*args, **kwargs) if response["status"] != "200": raise TwitterAPIError(body) return body try: oauth_token = cherrypy.request.params.get("oauth_token") oauth_verifier = cherrypy.request.params.get("oauth_verifier") oauth_secret_session_key = "twitter_auth.%s.oauth_secret" % self.id if not oauth_token or not oauth_verifier: # Obtain a request token client = Client(consumer) location = Location.get_current(relative=False) location.query_string["item_action"] = self.id callback = quote_plus(str(location)) body = request( client, "https://api.twitter.com/oauth/request_token" "?oauth_callback=" + callback, "GET") data = dict(parse_qsl(body)) session[oauth_secret_session_key] = data["oauth_token_secret"] # Redirect the user to the login form auth_url = ("https://api.twitter.com/oauth/authorize?" "oauth_token=%s" "&oauth_callback=%s" % (data["oauth_token"], callback)) raise cherrypy.HTTPRedirect(auth_url) else: token = Token(oauth_token, session[oauth_secret_session_key]) token.set_verifier(oauth_verifier) client = Client(consumer, token) body = request(client, 'https://api.twitter.com/oauth/access_token', "POST") data = dict(parse_qsl(body)) target.auth_token = data["oauth_token"] target.auth_secret = data["oauth_token_secret"] datastore.commit() except TwitterAPIError, ex: notify_user(translations(ex), category="error", transient=False)
def submit(self): Form.submit(self) purchase = self.instance["purchase"] product = purchase.product purchase.delete() Basket.store() notify_user( translations( "woost.extensions.ecommerce.delete_purchase_notice", product = product ), category = "success" ) Location.get_current().go("GET")
def submit(self): Form.submit(self) Basket.get().add_purchase(self.instance) Basket.store() notify_user(translations( "woost.extensions.ecommerce.product_added_notice", product=self.product), "product_added", transient=False) if self.redirect_to_basket: raise cherrypy.HTTPRedirect( Publishable.require_instance( qname="woost.extensions.ecommerce.basket_page"). get_uri()) else: Location.get_current().go("GET")
def submit(self): Form.submit(self) for purchase, quantity in zip( Basket.get().purchases, self.instance["quantity"] ): purchase.quantity = quantity Basket.store() notify_user( translations("woost.extensions.ecommerce." "set_quantities_notice"), category = "success" ) if self.controller.action != "proceed": Location.get_current().go("GET")
def invoke(self, controller, selection): clipboard = get_block_clipboard_contents() if not clipboard: notify_user( translations("woost.block_clipboard.empty"), "error" ) else: try: block = Block.require_instance(clipboard["block"]) src_parent = Item.require_instance(clipboard["block_parent"]) src_slot = type(src_parent).get_member(clipboard["block_slot"]) except: notify_user( translations("woost.block_clipboard.error"), "error" ) else: # Remove the block from the source location if clipboard["mode"] == "cut": if isinstance(src_slot, schema.Reference): src_parent.set(src_slot, None) elif isinstance(src_slot, schema.Collection): src_collection = src_parent.get(src_slot) schema.remove(src_collection, block) # Or copy it elif clipboard["mode"] == "copy": block = block.create_copy() block.insert() # Add the block to its new position add_block( block, controller.block_parent, controller.block_slot, positioning = self.block_positioning, anchor = controller.block ) datastore.commit() del session[BLOCK_CLIPBOARD_SESSION_KEY] focus_block(block)
def _synchronize(self): cmp = self.comparision get_param = cherrypy.request.params.get file_downloads = set() selection = self.sync_selection with changeset_context(get_current_user()): for obj in cmp["incomming"]: if obj.global_id in selection: obj.insert() if isinstance(obj, File): file_downloads.add(obj) for global_id, change in cmp["modified"].iteritems(): if global_id in selection: local = change["local"] remote = change["remote"] for member, lang in change["diff"]: value = schema.get(remote, member, language=lang) local.set(member, value, lang) if member in (File.file_hash, File.file_size): file_downloads.add(local) # Download files from the remote copy for file in file_downloads: self.synchronization.download_file(file) # Find importable content again self.comparision = self.synchronization.compare_content() notify_user( translations( "woost.controllers.InstallationSyncController.success"), "success")
def item_saved_notification(self, is_new, change): """Notifies the user that the node's item has been saved. @param is_new: Indicates if the save operation consisted of an insertion (True) or an update of an existing item (False). @type is_new: bool @param change: A change object describing the save operation. @type change: L{Change<woost.models.changeset.Change>} """ item = self.item msg = translations("woost.views.BackOfficeEditView Changes saved", item=item, is_new=is_new) transient = True if is_new and self.parent_node is None: controller = cherrypy.request.handler_chain[-1] msg += '. <a href="%s">%s</a>.' % ( controller.edit_uri(item.__class__, edit_stack=None), translations("woost.views.BackOfficeEditView Create another")) transient = False notify_user(msg, "success", transient)
def invoke(self, controller, selection): publication_target = selection[0] code = cherrypy.request.params.get("code") error = cherrypy.request.params.get("error") error_reason = cherrypy.request.params.get("error_reason") error_description = cherrypy.request.params.get("error_description") # Authorization failed if error: notify_user(translations( "woost.extensions.facebookauthentication." "fbpublish_auth.error", ), category="error", transient=False) # Authorization successful elif code: location = Location.get_current(relative=False) del location.query_string["code"] auth_url = ("https://graph.facebook.com/oauth/access_token?" "client_id=%s" "&redirect_uri=%s" "&client_secret=%s" "&code=%s" % (publication_target.app_id, quote_plus(str(location)), publication_target.app_secret, code)) response = urlopen(auth_url) response_status = response.getcode() response_body = response.read() if response_status < 200 or response_status > 299: notify_user(translations( "woost.extensions.facebookauthentication." "fbpublish_auth.oauth_error", response=response_body), category="error", transient=False) return auth_token = response_body.split("&")[0].split("=")[1] # Facebook pages require an additional authentication step fb_page_id = cherrypy.request.params.get("fb_page") if fb_page_id: accounts_url = ( "https://graph.facebook.com/%s/accounts?access_token=%s" % (publication_target.administrator_id, auth_token)) response_data = urlopen(accounts_url).read() json = loads(response_data) for account in json["data"]: if account["id"] == fb_page_id: auth_token = account["access_token"] break else: auth_token = None publication_target.auth_token = auth_token datastore.commit() notify_user(translations("woost.extensions.facebookauthentication." "fbpublish_auth.success"), category="success") # Begin authorization request else: # Determine if the selected graph URL is a Facebook Page graph_url = "http://graph.facebook.com/%s?metadata=1" \ % publication_target.graph_object_id response_data = urlopen(graph_url).read() json = loads(response_data) fb_page_id = json["metadata"]["type"] == "page" and json["id"] location = Location.get_current(relative=False) location.query_string["item_action"] = self.id permissions = "publish_stream,offline_access,user_photos" if fb_page_id: location.query_string["fb_page"] = fb_page_id permissions += ",manage_pages" auth_url = ("https://www.facebook.com/dialog/oauth?" "client_id=%s" "&redirect_uri=%s" "&scope=%s" % (publication_target.app_id, quote_plus(str(location)), permissions)) raise cherrypy.HTTPRedirect(auth_url)
def _handle_user_action_error(self, action, selection, error): if isinstance(error, tuple(self._graceful_user_action_errors)): notify_user(translations(error), "error") self.go_back() else: raise error
#-*- coding: utf-8 -*- u""" .. moduleauthor:: Jordi Fernández <*****@*****.**> """ from cocktail.events import event_handler from cocktail.translations import translations from woost.controllers.backoffice.editstack import EditNode from woost.controllers.notifications import notify_user class CampaignMonitorListEditNode(EditNode): @event_handler def handle_committed(cls, event): item = event.source.item try: item.update() except Exception, e: notify_user(translations( "woost.extensions.campaignmonitorlisteditnode.CampaignMonitorListEditNode failed synchronization", item=item, exception=e), "error", transient=False) else: notify_user( translations( "woost.extensions.campaignmonitorlisteditnode.CampaignMonitorListEditNode synchronized changes", item=item), "success")
data = dict(parse_qsl(body)) session[oauth_secret_session_key] = data["oauth_token_secret"] # Redirect the user to the login form auth_url = ("https://api.twitter.com/oauth/authorize?" "oauth_token=%s" "&oauth_callback=%s" % (data["oauth_token"], callback)) raise cherrypy.HTTPRedirect(auth_url) else: token = Token(oauth_token, session[oauth_secret_session_key]) token.set_verifier(oauth_verifier) client = Client(consumer, token) body = request(client, 'https://api.twitter.com/oauth/access_token', "POST") data = dict(parse_qsl(body)) target.auth_token = data["oauth_token"] target.auth_secret = data["oauth_token_secret"] datastore.commit() except TwitterAPIError, ex: notify_user(translations(ex), category="error", transient=False) else: notify_user(translations("woost.extensions.twitterpublication." "successful_authorization_notice"), category="success") TwitterAuthUserAction("twitter_auth").register()