def __call__(self, **parameters):
# Get references to the gateway and payment
gateway = get_parameter(
schema.Reference("gateway_id", type=DummyPaymentGateway))
if gateway is None:
raise ValueError("Wrong payment gateway")
payment_id = get_parameter(schema.String("payment_id"))
payment = payment_id and gateway.get_payment(payment_id) or None
if payment is None:
raise ValueError("Wrong payment id (%s)" % payment_id)
# Notify the payment to the application
cms = self.context["cms"]
notification_uri = Location.get_current_host()
notification_uri.path_info = cms.application_uri(
"payment_notification", payment_id=payment_id)
urlopen(str(notification_uri))
# Redirect the user after the transaction's over
redirection = None
if gateway.payment_status == "accepted":
redirection = gateway.payment_successful_page
elif gateway.payment_status == "failed":
redirection = gateway.payment_failed_page
raise cherrypy.HTTPRedirect((redirection and cms.uri(redirection)
or cms.application_uri()).encode("utf-8"))
def language_mode(self):
return get_parameter(schema.String(
"language_mode",
required=True,
enumeration=["all", "include", "exclude"],
default="all"),
errors="raise")
def visible_languages(self):
return get_parameter(schema.Collection("language",
items=schema.String(),
default=[get_language()]),
source=CookieParameterSource(
cookie_naming="visible_languages",
cookie_duration=self.settings_duration))
def request_edit_stack(self):
"""
Obtains the stack of edit operations for the current HTTP request, as
indicated by an HTTP parameter.
@param param: The name of the HTTP parameter that contains the unique
identifier of the stack to obtain.
@return: The current edit stack, or None if the "edit_stack" parameter
is missing.
@rtype: L{EditStack}
@raise WrongEditStackError: Raised if the requested edit stack can't be
found on the session.
"""
edit_stack = None
edit_stack_param = get_parameter(
schema.String(self._request_param, format=r"\d+-\d+"))
if edit_stack_param:
id, step = map(int, edit_stack_param.split("-"))
edit_stack = self._get_edit_stack(id)
# Edit state lost
if edit_stack is None:
raise WrongEditStackError(id)
# Prune the stack
else:
while len(edit_stack) > step + 1:
edit_stack.pop()
return edit_stack
def selection(self):
return get_parameter(schema.Collection("selection",
items=schema.Reference(
type=Publishable,
required=True),
min=1),
errors="raise")
def pagination(self):
return get_parameter(Pagination.copy(
**{
"page_size.default": 20,
"page_size.max": 100,
"items": self.products
}),
errors="set_default")
def sibling(self):
target_member = self.target_member
if target_member and isinstance(target_member, schema.Collection):
return get_parameter(
schema.Reference(
"sibling",
type=target_member.related_type,
enumeration=self.target_object.get(target_member)))
def target_member(self):
eligible_members = [member.name for member in self.eligible_members]
if eligible_members:
member_name = get_parameter(
schema.String("target_member", enumeration=eligible_members))
if member_name:
return self.target_object.__class__.get_member(member_name)
def get_slot_parameter(parent, parameter_name):
if parent is not None:
slot_name = get_parameter(schema.String(parameter_name))
if slot_name:
slot = type(parent).get_member(slot_name)
if (slot is not None and isinstance(slot, schema.RelationMember)
and slot.related_type
and issubclass(slot.related_type, Block)):
return slot
def relation_selection(self):
member = self.relation_member
value = get_parameter(
Collection(
name = "relation_selection-" + member.name,
items = Reference(type = member.related_type)
)
)
if not value:
return []
else:
enum = frozenset(self.stack_node.form_data.get(member.name))
return [item for item in value if item in enum]
def preview_publishable(self):
publishable = get_parameter(
schema.Reference("preview_publishable", type=Publishable))
if publishable is not None:
return publishable
for node in reversed(self.edit_stack):
item = getattr(node, "item", None)
if item is not None and isinstance(item, Publishable):
return item
if isinstance(self.previewed_item, Block):
for path in self.previewed_item.find_paths():
container = path[0][0]
if isinstance(container, Publishable):
publishable = container
break
def pagination(self):
return get_parameter(self.pagination_member,
errors="set_default",
prefix=self.name_prefix,
suffix=self.name_suffix)
def dragged_object(self):
return get_parameter(schema.Reference("dragged_object", type=Item))
def __call__(self, **kwargs):
app.user.require_permission(ReadReportsPermission)
form_data = get_parameter(report_schema, errors="raise")
config = Configuration.instance
custom_defs = config.google_analytics_custom_definitions
reports = []
base_report = {
"viewId":
form_data["view"].identifier,
"dateRanges": [{
"startDate":
form_data["start_date"].strftime("%Y-%m-%d"),
"endDate":
form_data["end_date"].strftime("%Y-%m-%d")
}],
"samplingLevel":
"LARGE",
"pageSize":
10000
}
source_publishable = form_data.get("source_publishable")
if source_publishable:
publishable_custom_def = CustomDefinition.get_instance(
qname="woost.extensions.googleanalytics."
"default_custom_definitions.publishable")
publishable_dim = ("ga:dimension%d" %
(custom_defs.index(publishable_custom_def) + 1))
base_report["dimensionFilterClauses"] = {
"operator":
"AND",
"filters": [{
"dimensionName": publishable_dim,
"operator": "PARTIAL",
"expressions": ["--%d--" % source_publishable.id]
}]
}
agg_report = deepcopy(base_report)
agg_report["dimensions"] = [{"name": "ga:eventLabel"}]
agg_report["metrics"] = [{"expression": "ga:totalEvents"}]
reports.append(agg_report)
target_custom_def = CustomDefinition.get_instance(
qname="woost.extensions.googleanalytics."
"default_custom_definitions.target")
if target_custom_def:
target_report = deepcopy(agg_report)
target_report["dimensions"].append({
"name":
"ga:dimension%d" % (custom_defs.index(target_custom_def) + 1)
})
reports.append(target_report)
if source_publishable:
page_report = deepcopy(base_report)
page_report["dimensions"] = [{"name": publishable_dim}]
page_report["metrics"] = [{"expression": "ga:pageviews"}]
reports.append(page_report)
request_data = {"reportRequests": reports}
client = get_client()
report = get_report(client, request_data)
cherrypy.response.headers["Content-Type"] = "application/json"
return json.dumps(report)
def form_data(self):
return get_parameter(self.form_schema, errors="ignore")
def include_neutral_language(self):
return get_parameter(schema.Boolean("include_neutral_language",
required=True,
default=True),
implicit_booleans=False,
errors="raise")
def client_side_scripting(self):
return get_parameter(schema.Boolean("client_side_scripting"))
def preview_publishable(self):
return get_parameter(
schema.Reference("preview_publishable", type=Publishable))
def position(self):
return get_parameter(
schema.Integer("position", min=0, max=len(self.collection)))
def pending_only(self):
return get_parameter(schema.Boolean("pending_only",
required=True,
default=False),
implicit_booleans=False,
errors="raise")
def include_descendants(self):
return get_parameter(schema.Boolean("include_descendants",
required=True,
default=False),
implicit_booleans=False,
errors="raise")
def preview_language(self):
return get_parameter(
schema.String("preview_language", default=get_language()))
def member(self):
key = get_parameter(schema.String("member"))
return self.item.__class__.get_member(key) if key else None
def action(self):
return get_parameter(schema.String("action"))
def target_object(self):
return get_parameter(schema.Reference("target_object", type=Item))
def language_subset(self):
return get_parameter(schema.Collection("language_subset",
items=LocaleMember()),
errors="raise")
def destination(self):
return get_parameter(schema.Reference("destination",
type=Destination,
required=True),
errors="raise")
def selection(self):
return get_parameter(
schema.Collection("selection",
items=schema.Reference(type=self.content_type)))
def relative_placement(self):
return get_parameter(
schema.String("relative_placement",
enumeration=["after", "before"]))
def selection(self):
return get_parameter(schema.Collection(
"selection", items=schema.Reference(type=Item)),
errors="raise")
