def data_users(self, ctx, data):
"""Fetch and return a list of registered users known to the system.
"""
storeSession = util.getStoreSession(ctx)
d = self.application.getManager()
d.addCallback(lambda manager: manager.findMany(util.getStoreSession(ctx)))
return d
def registered_users_csv(self, ctx):
def gotUsers(users):
fileData = StringIO()
writer = csv.writer(fileData, dialect="excel")
for user in users:
writer.writerow([user.first_name, user.surname, user.optin, user.comments, user.email])
return static.Data(fileData.getvalue(), 'text/comma-separated-values')
storeSession = util.getStoreSession(ctx)
d = self.application.getManager()
d.addCallback(lambda manager: manager.findMany(util.getStoreSession(ctx)))
d.addCallback(gotUsers)
return d
def data_facets(ctx, data):
storeSession = util.getStoreSession(ctx)
avatar = util.getAvatar(ctx)
@defer.deferredGenerator
def loadCategories(facets):
d = defer.waitForDeferred(avatar.getCategoryManager(storeSession))
yield d
categories = d.getResult()
rv = []
for f in facets:
facetData = FacetData()
facetData.label = f[2]
facetData.textid = f[1]
rv.append(facetData)
d = defer.waitForDeferred(categories.loadCategories(facetData.textid))
yield d
facetData.tree = d.getResult().children
yield rv
d = avatar.getCategoryManager(storeSession)
d.addCallback(lambda categories: categories.loadFacets())
d.addCallback(loadCategories)
return d
def get(self, ctx):
# Get bits we need from the context
avatar = ctx.locate(icrux.IAvatar)
sess = util.getStoreSession(ctx)
# Is this for a single item?
if self.original.id:
return avatar.realm.cmsService.getContentManager(avatar).publicFindById(sess, self.original.id)
# Determine the item type we are retrieving
itemType = self.original.type
if itemType is not None:
itemType = sess.store.registry.typeWithName(itemType)
where = []
params = {}
# Add categories to where, if any
categories = [c for c in self.original.categories if c]
if categories is not None:
for i, category in enumerate(categories):
marker = 'cat%s'%i
where.append('categories <@ %%(%s)s'%marker)
params[marker] = category
if self.original.name:
where.append('name=%(name)s')
params['name'] = self.original.name
if where:
where = ' and '.join(where)
else:
where = None
return avatar.realm.cmsService.getContentManager(avatar).publicFindManyContentItems(sess, itemType=itemType, where=where, params=params)
def _submit_editPage(self, ctx, form, data):
"""Handle editPage form submission.
"""
storeSession = tub_util.getStoreSession(ctx)
def nodeUpdated(r):
if self.original.path == self.rootPath:
u = url.URL.fromContext(ctx)
else:
u = url.URL.fromContext(ctx).sibling(self.original.name)
return u.replace('message', 'Site Map node updated successfully')
def catchUnauthorizedException(failure):
failure.trap(UnauthorizedException)
u = url.URL.fromContext(ctx)
storeSession.forceRollback = True
return u.replace('errormessage', 'You do not have permission to update the site map.')
app, id = self._unmapItem(data['page'])
if self.original.path != self.rootPath:
d = self.manager.updateNode(self.original, app, id, name=data['nodeName'], label=data['navigationLabel'], level=data['navigationLevel'])
else:
d = self.manager.updateNode(self.original, app, id, label=data['navigationLabel'])
d.addCallback(nodeUpdated)
d.addErrback(catchUnauthorizedException)
return d
def _submit(self, ctx, form, data):
sess = util.getStoreSession(ctx)
def updated(customer):
return url.URL.fromContext(ctx).replace('message', 'Customer updated successfully')
def updateFailed(failure):
failure.trap(NotFound)
util.getStoreSession(ctx).forceRollback = True
return url.URL.fromContext(ctx).replace('errormessage', 'Customer update failed. Someone else has already changed the customer.')
def update(ignore):
for attr in ('email', 'last_name', 'first_name', 'phoneNumber',
'billingAddress1', 'billingAddress2', 'billingAddress3',
'billingCity', 'billingPostcode', 'billingCountry', 'optIn',
'gender', 'dateOfBirth', 'secretQuestion', 'secretAnswer'):
value = data[attr]
setattr(self.original, attr, value)
if data['password']:
self.original.password = data['password']
d = self.application.getManager()
d.addCallback(lambda manager: manager.update(self.original, sess) )
return d
data = getDataFromForm(form, data)
d = defer.Deferred()
d.addCallback(lambda ignore: update(data))
d.addCallback(lambda ignore: sess.flush())
d.addCallback(updated)
d.addErrback(updateFailed)
d.callback(None)
return d
def _submit(self, ctx, form, data):
sess = tub_util.getStoreSession(ctx)
def updated(artwork):
return url.URL.fromContext(ctx).replace('message', 'Artwork updated successfully')
def updateFailed(failure):
failure.trap(NotFound)
tub_util.getStoreSession(ctx).rollbackAlways = True
return url.URL.fromContext(ctx).replace('errormessage', 'Artwork update failed. Someone else has already changed the artwork.')
def update(ignore):
d = self.application.getManager()
d.addCallback(lambda manager: manager.update(self.original, data, sess) )
return d
data = getDataFromForm(form, data)
d = defer.Deferred()
d.addCallback(lambda ignore: update(data))
d.addCallback(lambda ignore: sess.flush())
d.addCallback(updated)
d.addErrback(updateFailed)
d.callback(None)
return d
def form_delivery_charge(self, ctx):
def convert(data):
if data is None:
data = []
return '\r\n'.join( [ ';'.join([str(i) for i in r]) for r in data ] )
def buildForm(item):
form = formal.Form()
form.addField('countries', formal.String(required=True), widgetFactory=formal.TextArea)
form.addField('rates', formal.String(required=True), widgetFactory=formal.TextArea)
form.addAction(self._update, label='Update')
form.data = {
'countries': convert(item.countries),
'rates': convert(item.rates)}
return form
storeSession = util.getStoreSession(ctx)
d = self.application.getManager()
d.addCallback(lambda manager: manager.find(storeSession))
d.addCallback(buildForm)
return d
def _locateComponentChild(self, ctx, segments):
avatar = itub.IAvatar(ctx, None)
if avatar is None:
return appserver.NotFound
try:
app, component = avatar.applications.componentByName(segments[0])
except KeyError:
return appserver.NotFound
# Build a list of skins provided by the application and/or component.
skins = [getattr(app, 'skin', None), getattr(component, 'skin', None)]
skins = [s for s in skins if s]
try:
storeSession = util.getStoreSession(ctx)
return util.appendSkinsAndCall(ctx, skins,
component.resourceFactory, avatar, storeSession,
segments[1:])
except TypeError:
import warnings
warnings.warn(
"IApplicationComponent.resourceFactory now takes a storeSession, please update %s."%component.name,
DeprecationWarning)
return util.appendSkinsAndCall(ctx, skins,
component.resourceFactory, avatar, segments[1:])
def _submit(self, ctx, form, data):
storeSession = util.getStoreSession(ctx)
def _updateStock(product, storeSession, manager, adjustment):
d = updateStock(storeSession, manager.getStockManager(), product.id, adjustment)
d.addCallback(lambda ignore: product)
return d
def addProduct(manager):
d = manager.create(storeSession, data)
d.addCallback(_updateStock, storeSession, manager, stockData.get('stock.adjustment'))
return d
def created(product):
return url.URL.fromContext(ctx).sibling(product.id).replace('message', 'Product added successfully')
stockData = extractGroup('stock.', data)
data = getDataFromForm(form, data)
d = self.application.getManager()
d.addCallback(addProduct)
d.addCallback(created)
return d
def data_voucher_definitions(self, ctx, data):
storeSession = util.getStoreSession(ctx)
def voucherDefinitionFactory():
return self.app.getManager().getVoucherDefinitions(storeSession)
return VoucherDefinitionsModel(voucherDefinitionFactory)
def _submit(self, ctx, form, data):
sess = util.getStoreSession(ctx)
def userUpdated(user):
return url.URL.fromContext(ctx).replace('message', 'User updated successfully')
def updateFailed(failure):
failure.trap(NotFound)
util.getStoreSession(ctx).rollbackAlways = True
return url.URL.fromContext(ctx).replace('errormessage', 'User update failed. Someone else has already changed the user.')
def update(data):
self.original.first_name = data['first_name']
self.original.surname = data['surname']
self.original.email = data['email']
self.original.comments = data['comments']
self.original.optin = data['optin']
self.original.touch()
# Don't allow the user name to be changed
d = defer.Deferred()
d.addCallback(lambda ignore: update(data))
d.addCallback(lambda ignore: sess.flush())
d.addCallback(userUpdated)
d.addErrback(updateFailed)
d.callback(None)
return d
def data_facets(self,ctx,data):
# Get a list of category facets
def getFacetNames(facets):
facets = [ {'label':f[2],'textid':f[1]} for f in facets ]
return facets
storeSession = util.getStoreSession(ctx)
d = self.avatar.getCategoryManager(storeSession)
d.addCallback(lambda categories: categories.loadFacets())
d.addCallback(getFacetNames)
return d
def _submit(self, ctx, form, data):
sess = util.getStoreSession(ctx)
def userCreated(user):
return url.URL.fromContext(ctx).sibling(user.id).replace('message', 'User added successfully')
d = self.application.getManager()
d.addCallback(lambda manager: manager.registerUser(sess,data['first_name'],data['surname'],data['optin'],data['comments'],data['email']))
d.addCallback(userCreated)
return d
def data_searchresults(self, ctx, data):
args = inevow.IRequest(ctx).args
query = args.get('categories', [''])
avatar = icrux.IAvatar(ctx)
storeSession = util.getStoreSession(ctx)
d = self.imageFactory.getImages(avatar, storeSession, query)
d.addCallback(self._setUpPaging, ctx)
return d
def _update(self, ctx, form, data):
def updated():
return url.URL.fromContext(ctx).sibling(self.voucherDefinition.voucher_definition_id).replace('message', 'Voucher updated successfully')
self.voucherType.getEditor().update(self.voucherDefinition, data)
storeSession = util.getStoreSession(ctx)
d = self.app.getManager().update(storeSession, self.voucherDefinition)
d.addCallback(lambda ignore: updated())
return d
def render_fragmentTemplate(self,ctx,data):
sess = util.getStoreSession(ctx)
items = yield sess.getItems(fragmenttype.FragmentType)
for item in items:
if item.name == self.original.protectedObject.type:
fragmentType = item
break
template = fragmentType.template
from genshi.template import NewTextTemplate as TextTemplate
tmpl = TextTemplate(fragmentType.template)
output = tmpl.generate(**self.original.protectedObject.data)
returnValue(T.xml(output.render('text')))
def _create(self, ctx, form, data):
creator = self.voucherType.getCreator()
voucherDefinition = creator.create(ctx, form, data)
def created(voucher):
return url.URL.fromContext(ctx).sibling(voucher.voucher_definition_id).replace('message', 'Voucher added successfully')
storeSession = util.getStoreSession(ctx)
d = self.app.getManager().add(storeSession, voucherDefinition)
d.addCallback(created)
return d
def _moveNode(self, ctx, nodeId, direction):
storeSession = tub_util.getStoreSession(ctx)
def nodeMoved(r):
return url.URL.fromContext(ctx).replace('message', 'Child site map node moved successfully')
def catchUnauthorizedException(failure):
failure.trap(UnauthorizedException)
u = url.URL.fromContext(ctx)
storeSession.forceRollback = True
return u.replace('errormessage', 'You do not have permission to update the site map.')
d = self.manager.moveNode(self.original.findChildById(nodeId), direction)
d.addCallback(nodeMoved)
d.addErrback(catchUnauthorizedException)
return d
def _submit(self, ctx, form, data):
sess = tub_util.getStoreSession(ctx)
def created(artwork):
return url.URL.fromContext(ctx).sibling(artwork.id).replace('message', 'Artwork added successfully')
data = getDataFromForm(form, data)
d = self.application.getManager()
d.addCallback(lambda manager: manager.create(sess, data))
d.addCallback(created)
return d
def child_products_csv(self, ctx):
DECIMAL_ZERO = Decimal('0.00')
def encodeValue(value):
value = unicode(value or '').encode('utf8')
return value
def getAttrDict(product):
rv = {}
for attr in product._attrs:
value = getattr(product,attr, None)
if isinstance(value, RichTextData):
# Get the content out of Rich Text types
value = encodeValue(value.content)
elif isinstance(value, (types.ListType, types.TupleType)):
# encode the items in the list
value = [encodeValue(v) for v in value if v]
if value == []:
value = encodeValue('')
elif value and attr in ( 'mainImage'):
# create a url for images
value = '/system/ecommerce/%s/%s'%(product.id,attr)
value = encodeValue(value)
elif isinstance(value, Decimal):
# Put pence into prices
value = value.quantize(DECIMAL_ZERO)
value = encodeValue(value)
else:
value = encodeValue(value)
rv[attr] = value
return rv
def gotProducts(products):
fileData = StringIO()
writer = None
for product in products:
if writer is None:
writer = csv.DictWriter(fileData, product._attrs, dialect="excel")
writer.writerow( dict([(a,a) for a in product._attrs]) )
writer.writerow(getAttrDict(product))
return static.Data(fileData.getvalue(), 'text/comma-separated-values')
storeSession = util.getStoreSession(ctx)
d = self.application.getManager()
d.addCallback(lambda manager: manager.findMany(storeSession))
d.addCallback(gotProducts)
return d
def data_salesorders(self, ctx, data):
"""
Build a sales model for the view.
"""
# Get the status, default to confirmed
status = ctx.arg('status') or manager.SalesOrder.CONFIRMED
storeSession = util.getStoreSession(ctx)
def salesOrdersFactory():
def _(**kw):
return self.app.getManager().getSalesOrders(storeSession, **kw)
return _
return SalesOrdersModel(salesOrdersFactory(), status=status)
def childFactory(self, ctx, userId):
# User IDs are always ints
try:
userId = int(userId)
except ValueError:
return None
def error(failure):
failure.trap(objstore.NotFound)
return None
sess = util.getStoreSession(ctx)
d = self.application.getManager()
d.addCallback(lambda manager: manager.findById(sess, userId))
return d.addCallback(EditUserPage).addErrback(error)
def childFactory(self, ctx, id):
# IDs are always ints
try:
id = int(id)
except ValueError:
return None
def error(failure):
failure.trap(NotFound)
return None
sess = util.getStoreSession(ctx)
d = self.application.getManager()
d.addCallback(lambda manager: manager.findById(sess, id))
return d.addCallback(EditProductPage, self.application).addErrback(error)
def _moveCategory(self, ctx, textid, direction):
def moved(r):
return url.URL.fromContext(ctx).replace('message', 'Category moved successfully')
def catchUnauthorizedException(failure):
failure.trap(capabilities.UnauthorizedException)
u = url.URL.fromContext(ctx)
sess.forceRollback = True
return u.replace('errormessage', 'You do not have permission to update categories.')
storeSession = util.getStoreSession(ctx)
d = self.avatar.getCategoryManager(storeSession)
d.addCallback(lambda categories: categories.moveNode(self.node.findChildById(textid), direction))
d.addCallback(moved)
d.addErrback(catchUnauthorizedException)
return d
def _submit_addCategory(self, ctx, form, data):
def added(r):
return url.URL.fromContext(ctx).replace('message', 'Category added successfully')
def addError( failure ):
failure.trap(error.NotUniqueError)
raise xforms.FieldValidationError( 'duplicate textid', 'textid' )
def catchUnauthorizedException(failure):
failure.trap(capabilities.UnauthorizedException)
u = url.URL.fromContext(ctx)
sess.forceRollback = True
return u.replace('errormessage', 'You do not have permission to update categories.')
storeSession = util.getStoreSession(ctx)
d = self.avatar.getCategoryManager(storeSession)
d.addCallback(lambda categories: categories.addChildToNode(self.node, data['textid'], data['label']))
d.addCallbacks(added,addError)
d.addErrback(catchUnauthorizedException)
return d
def childFactory(self, ctx, name):
"""
Create a resource for the Sale instance.
"""
# A sale is always identified by an int
try:
salesOrderId = int(name)
except ValueError:
return
# Find the sale.
storeSession = util.getStoreSession(ctx)
d = self.app.getManager().getSalesOrder(storeSession, salesOrderId)
# Create the resource to edit the sale
d.addCallback(lambda salesOrder: SalesOrderPage(self.avatar, self.app, salesOrder))
return d
def childFactory(self, ctx, name):
"""
Create a resource for the Voucher Definition instance.
"""
# A sale is always identified by an int
try:
id = int(name)
except ValueError:
return
# Find the sale.
storeSession = util.getStoreSession(ctx)
d = self.app.getManager().getVoucherDefinition(storeSession, id)
# Create the resource to edit the sale
d.addCallback(lambda voucherDefinition: EditVoucherDefinitionPage(self.avatar,
self.app, voucherDefinition, self.voucherType))
return d
def _submit(self, ctx, form, data):
storeSession = util.getStoreSession(ctx)
def updated():
return url.URL.fromContext(ctx).replace('message', 'Product updated successfully')
def updateFailed(failure):
failure.trap(NotFound)
util.getStoreSession(ctx).forceRollback = True
return url.URL.fromContext(ctx).replace('errormessage', 'Product update failed. Someone else has already changed the product.')
def update(manager, data):
def _updateStock(storeSession, stockManager, adjustment):
# Only manage stock on the product directly if it has no options
if not self.original.hasOptions():
d = updateStock(storeSession, stockManager, self.original.id, adjustment)
d.addCallback(lambda ignore: tidyStock(storeSession, stockManager, self.original))
else:
d = defer.succeed(None)
return d
optionsData = extractGroup('options.', data)
stockData = extractGroup('stock.', data)
data = getDataFromForm(form, data)
d = defer.succeed(None)
if manager.hasOptionManager():
# Check for and process options first
d.addCallback(lambda ignore: updateOptions(storeSession, manager, self.original, optionsData))
d.addCallback(lambda ignore: _updateStock(storeSession, manager.getStockManager(), stockData.get('stock.adjustment')))
d.addCallback(lambda ignore: manager.update(self.original, data, storeSession))
return d
d = self.application.getManager()
d.addCallback(update, data)
d.addCallback(lambda ignore: storeSession.flush())
d.addCallback(lambda ignore: updated())
d.addErrback(updateFailed)
return d
def _submit_editCategory(self, ctx, form, data):
"""Handle editCategory form submission.
"""
def categoryUpdated(r):
u = url.URL.fromContext(ctx).sibling(self.node.textid)
return u.replace('message', 'Category updated succesfully')
def catchUnauthorizedException(failure):
failure.trap(capabilities.UnauthorizedException)
u = url.URL.fromContext(ctx)
sess.forceRollback = True
return u.replace('errormessage', 'You do not have permission to update categories.')
storeSession = util.getStoreSession(ctx)
d = self.avatar.getCategoryManager(storeSession)
d.addCallback(lambda categories: categories.updateNode(self.node, data['textid'], data['label']))
d.addCallback(categoryUpdated)
d.addErrback(catchUnauthorizedException)
return d
