def saveHandler(self, action):
data = {}
for key, val in self.request.params.items():
if key.startswith('field.'):
data[key[6:]] = val
if data:
self.context.updateWidgetMapping(data)
view.addMessage(self.request, 'Fields widgets have been saved.')
def removeHandler(self, action):
ids = self.request.params.getall("field-id")
for id in ids:
field = self.context[id]
event.notify(ObjectRemovedEvent(field, self.context, id))
del self.context[id]
if ids:
view.addMessage(self.request, "Selected fields have been removed.")
def test_messages_render(self):
self._init_memphis()
view.addMessage(self.request, 'message')
msg = view.renderMessages(self.request)
self.assertEqual(msg, u'<div class="alert-message info">\n <a class="close" href="#">\xd7</a>\n <p>message</p>\n</div>\n')
self.assertEqual(type(msg), unicode)
msg = view.renderMessages(self.request)
self.assertEqual(msg, '')
def modifyHandler(self, action):
data = {}
for key, val in self.request.params.items():
if key.startswith('field:') and val != '__sys_default__':
schName, fldId = key[6:].split(':', 1)
data.setdefault(schName, {})[fldId] = val
if data != self.context.widgets:
self.context.widgets = data
view.addMessage(self.request, 'Widgets have been modified.')
def modifyHandler(self, action):
ids = self.request.params.getall('field-id')
hidden = {}
for fid in ids:
sch, field = fid.split(':', 1)
hidden.setdefault(sch, []).append(field)
self.context.hiddenFields = hidden
view.addMessage(self.request, 'Hidden fields have been modified.')
def test_messages_addmessage(self):
self._init_memphis()
service = IStatusMessage(self.request)
# addMessage
view.addMessage(self.request, 'message')
self.assertEqual(service.clear(),
[u'<div class="alert-message info">\n <a class="close" href="#">\xd7</a>\n <p>message</p>\n</div>\n'])
self.assertEqual(service.clear(), ())
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
view.addMessage(self.request, self.formErrorsMessage, 'warning')
else:
obj = self.createAndAdd(data)
if obj is not None:
self.addedObject = obj
self.finishedAdd = True
raise HTTPFound(location = '../../')
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
view.addMessage(
self.request, self.formErrorsMessage, 'formError')
else:
for form in self.subforms:
data, errors = form.extractData(setErrors=False)
form.applyChanges(data)
obj = self.createAndAdd(data.get('name',''), self.datasheets)
if obj is not None:
raise HTTPFound(location = self.nextURL(obj))
def removeHandler(self, action):
user = self.context
conn = ploud_config.PLOUD_POOL.getconn()
cursor = conn.cursor()
pol = POLICIES[user.type]
pol.removeSite(self.site.id, cursor)
site.removed = True
cursor.close()
conn.commit()
ploud_config.PLOUD_POOL.putconn(conn)
view.addMessage(request, "Site has been removed.")
raise HTTPFound(location='index.html')
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
view.addMessage(self.request, (self.formErrorsMessage,) + errors, "formError")
return
changes = self.applyChanges(data)
obj = self.createAndAdd(self.datasheets)
if obj is not None:
self.addedObject = obj
self.finishedAdd = True
raise HTTPFound(location=self.nextURL())
def updateHandler(self, action):
data, errors = self.extractData()
if not errors:
site = self.context
if site.disabled != data['disabled']:
site.disabled = data['disabled']
if site.disabled:
utils.disableHost(site)
else:
utils.enableHost(site)
view.addMessage(self.request, 'Site info has been updated.')
def update(self):
request = self.request
ptool = self.ptool = getUtility(IPasswordTool)
passcode = request.params.get("passcode")
principal = self.ptool.getPrincipal(passcode)
self.info = IUserInfo(principal)
if principal is not None:
self.passcode = passcode
self.principal = principal
else:
view.addMessage(request, _("Passcode is invalid."), "warning")
raise HTTPFound(location="%s/resetpassword.html" % request.application_url)
super(ResetPasswordForm, self).update()
def handle_register(self, action):
request = self.request
data, errors = self.extractData()
if errors:
view.addMessage(request, self.formErrorsMessage, 'error')
return
self.setPrincipal(self.create(data))
user = getUtility(IAuthentication).getUserByLogin(data['login'])
headers = security.remember(request, user.id)
raise HTTPFound(
location='%s/login-success.html'%request.application_url,
headers = headers)
def changeUserType(self, action):
data, errors = self.extractData()
if not errors:
view.addMessage(
self.request,
"User's membership type has been change.")
user = self.context
if user.type != data['policy']:
user.type = data['policy']
conn = ploud_config.PLOUD_POOL.getconn()
cursor = conn.cursor()
POLICIES[user.type].apply(user.id, cursor)
cursor.close()
conn.commit()
ploud_config.PLOUD_POOL.putconn(conn)
def update(self):
super(ContentTypeSchemas, self).update()
self.adapters = getSiteManager().adapters
self.requestProvided = interface.providedBy(self.request)
context = self.context
request = self.request
if 'form-addschema' in request.params:
view.addMessage(
request, 'Content type schemas have been modified.')
context.schemas = context.schemas + tuple([
id for id in request.params.getall('schema-id')
if id not in context.schemas])
schemas = {}
for name, sch in getUtilitiesFor(ISchemaType):
schemas[name] = (sch.title, sch)
for name, sch in getUtilitiesFor(schema.ISchemaType):
schemas[name] = (sch.title, sch)
enabled = []
for schId in self.context.schemas:
if schId in schemas:
enabled.append(schemas[schId][1])
self.enabled = enabled
schemas = schemas.values()
schemas.sort()
self.schemas = [sch for t, sch in schemas
if sch.name not in self.context.schemas]
fields = []
for sch, data in self.context.hiddenFields.items():
for fid in data:
fields.append('%s:%s'%(sch, fid))
self.fields = fields
def update(self):
site = None
try:
id = int(self.request.params.get('id'))
for s in self.context.sites:
if s.id == id:
site = s
break
if site is not None:
self.site = site
except HTTPFound:
raise
except:
pass
if site is None:
view.addMessage(self.request, 'Site id is required.')
raise HTTPFound(location='index.html')
super(RemoveSiteView, self).update()
def changeOrder(self, names, up=True):
schemas = list(self.context.schemas)
schemas_len = len(schemas)
for name in names:
idx = schemas.index(name)
if up:
new = idx - 1
if new < 0 or schemas[new] in names:
continue
else:
new = idx + 1
if new >= schemas_len or schemas[new] in names:
continue
del schemas[idx]
schemas.insert(new, name)
self.context.schemas = tuple(schemas)
view.addMessage(self.request, 'Schemas order has been changed.')
def changeOrder(self, ids, direction=0):
context = self.context
changed = False
schema = context.schema
for field_id in ids:
field = context[field_id]
fields = [name for name, f in getFieldsInOrder(schema)]
cur_pos = fields.index(field_id)
if direction == 1:
new_pos = cur_pos - 1
if new_pos < 0 or fields[new_pos] in ids:
continue
slice_end = new_pos - 1
if slice_end == -1:
slice_end = None
intervening = [schema[field_id] for field_id in fields[cur_pos - 1 : slice_end : -1]]
else:
new_pos = cur_pos + 1
if new_pos > len(ids) + 1 or fields[new_pos] in ids:
continue
intervening = [schema[field_id] for field_id in fields[cur_pos + 1 : new_pos + 1]]
# changing order
prev = field.order
for f in intervening:
order = f.order
f.order = prev
prev = order
field.order = prev
changed = True
context.updateSchema()
if changed:
view.addMessage(self.request, u"Fields srder has been changed.")
def update(self):
super(ResetPassword, self).update()
request = self.request
mailer = getUtility(mail.IMailer)
self.from_name = mailer.email_from_name
self.from_address = mailer.email_from_address
if request.params.has_key("button.send"):
login = request.params.get("login", "")
principal = getUtility(IAuthentication).getUserByLogin(login)
if principal is not None:
passcode = getUtility(IPasswordTool).generatePasscode(principal)
template = ResetPasswordTemplate(principal, request)
template.passcode = passcode
template.send()
view.addMessage(request, _("Your password has been reset and is being emailed to you."))
raise HTTPFound(location=request.application_url)
view.addMessage(request, _(u"System can't restore password for this principal."))
def changePassword(self, action):
request = self.request
data, errors = self.extractData()
if errors:
view.addMessage(request, self.formErrorsMessage, "error")
else:
try:
self.ptool.resetPassword(self.passcode, data["password"])
except Exception, exc:
view.addMessage(request, str(exc), "warning")
return
user = getUtility(IAuthentication).getUserByLogin(self.info.login)
headers = security.remember(request, user.id)
view.addMessage(request, _("You have successfully changed your password."))
raise HTTPFound(headers=headers, location=request.application_url)
def removeHandler(self, action):
rem_sch = self.request.params.getall('schema-id')
self.context.schemas = tuple(
[sch for sch in self.context.schemas if sch not in rem_sch])
view.addMessage(self.request,'Content type schemas have been modified.')
def saveHandler(self, action):
self.context.behaviors = self.request.params.getall('behavior-id')
view.addMessage(
self.request, 'Content type behaviors have been modified.')
def handleCancel(self, action):
view.addMessage(self.request, self.formCancelMessage)
raise HTTPFound(location=self.cancelURL())
def handleTestSchema(self, action):
data, errors = self.extractData()
if errors:
view.addMessage(self.request, self.formErrorsMessage, "error")
else:
view.addMessage(self.request, _("Schema has been processed successfully."))
