class Login(form.FormBase):
form_fields = form.Fields(ILoginForm)
prefix = ""
form_name = _(u"Login")
template = NamedTemplate("alchemist.form")
def __call__(self):
if not IUnauthenticatedPrincipal.providedBy(self.request.principal):
app = getSite()
workspace = app["workspace"]
self.request.response.redirect(
ui_utils.url.absoluteURL(workspace, self.request))
return super(Login, self).__call__()
@form.action(_(u"Login"))
def handle_login(self, action, data):
if IUnauthenticatedPrincipal.providedBy(self.request.principal):
self.status = _(u"Invalid account credentials")
else:
site_url = ui_utils.url.absoluteURL(getSite(), self.request)
camefrom = self.request.get('camefrom', site_url + '/')
self.status = _("You are now logged in")
self.request.response.redirect(camefrom)
class ReorderForm(PageForm):
"""Item reordering form.
We use an intermediate list of ids to represent the item order.
Note that this form must be subclassed with the ``save_ordering``
method overriden.
"""
class IReorderForm(interface.Interface):
ordering = schema.List(title=u"Ordering", value_type=schema.TextLine())
template = NamedTemplate("alchemist.form")
form_name = _(u"Item reordering")
form_fields = formlib.form.Fields(IReorderForm, render_context=True)
def setUpWidgets(self, ignore_request=False):
class context:
ordering = list(self.context)
self.adapters = {
self.IReorderForm: context,
}
self.widgets = formlib.form.setUpWidgets(self.form_fields,
self.prefix,
self.context,
self.request,
form=self,
adapters=self.adapters,
ignore_request=ignore_request)
def save_ordering(self, ordering):
raise NotImplementedError("Must be defined by subclass")
@formlib.form.action(_(u"Save"), name="save")
def handle_save(self, action, data):
self.save_ordering(data["ordering"])
class RestoreLogin(form.FormBase):
form_fields = form.Fields(IRestoreLoginForm)
prefix = ""
form_name = _(u"Restore Login")
template = NamedTemplate("alchemist.form")
def __call__(self):
if not IUnauthenticatedPrincipal.providedBy(self.request.principal):
app = getSite()
workspace = app["workspace"]
self.request.response.redirect(
ui_utils.url.absoluteURL(workspace, self.request))
return super(RestoreLogin, self).__call__()
@form.action(_(u"Restore"), name="restore")
def handle_restore(self, action, data):
email = data.get("email", "")
if email:
app = BungeniApp()
settings = EmailSettings(app)
session = Session()
user = session.query(User).filter(User.email == email).first()
if user:
mailer = getUtility(IBungeniMailer)
self.message = _(u"Your login is: ") + user.login
text = ViewPageTemplateFile("templates/mail.pt")(self)
message = MIMEText(text)
message.set_charset("utf-8")
message["Subject"] = _(u"Bungeni login restoration")
message["To"] = email
mailer.send(message)
self.status = _(u"Your login was sent to you email.")
else:
self.status = _(u"Wrong email address.")
class ChangePasswordForm(BaseForm):
form_fields = form.Fields(IChangePasswordForm)
prefix = ""
form_name = _("change_password_form_title",
default=u"Change password")
# !+ only used here [ bungeni.ui.login.Login ] ?
template = NamedTemplate("alchemist.form")
def __init__(self, *args, **kwargs):
super(ChangePasswordForm, self).__init__(*args, **kwargs)
self.session = Session()
self.user = get_db_user(self.context)
def __call__(self):
if IUnauthenticatedPrincipal.providedBy(self.request.principal):
self.request.response.redirect(
ui_utils.url.absoluteURL(
getSite(), self.request)+"/login"
)
return super(ChangePasswordForm, self).__call__()
@form.action(_("label_change_password", default=u"Change password"),
name="change_password")
def save_password(self, action, data):
password = data.get("pswd","")
confirm_password= data.get("confirm_password","")
if password:
if password != confirm_password:
self.status = _("Password confirmation failed")
return
self.user._password = password
self.status = _("Password changed")
class OAuthAuthorizeForm(form.FormBase):
class IOAuthAuthorizeForm(interface.Interface):
client_id = schema.TextLine(required=False)
state = schema.TextLine(required=False)
time = schema.TextLine(required=False)
nonce = schema.TextLine(required=False)
form_fields = form.Fields(IOAuthAuthorizeForm)
form_fields["client_id"].custom_widget = widgets.HiddenTextWidget
form_fields["state"].custom_widget = widgets.HiddenTextWidget
form_fields["nonce"].custom_widget = widgets.HiddenTextWidget
form_fields["time"].custom_widget = widgets.HiddenTextWidget
template = NamedTemplate("alchemist.form")
form_name = _("authorise_oauth_application",
default=u"Authorise OAuth Application")
def __init__(self, context, request, parameters={}):
self.parameters = parameters
if self.parameters:
self.parameters["time"] = time.time()
self.parameters["nonce"] = self.generate_nonce(
self.parameters["client_id"], self.parameters["time"])
self.action_url = "/oauth/authorize-form"
super(OAuthAuthorizeForm, self).__init__(context, request)
def __call__(self):
authorization_token = self.check_authorization()
if authorization_token:
redirect_uri = self.get_redirect_uri(
authorization_token, self.request.form.get("state", None))
self.request.response.redirect(redirect_uri, trusted=True)
else:
return super(OAuthAuthorizeForm, self).__call__()
def get_authorization_token(self, authorization):
authorization_token = domain.OAuthAuthorizationToken()
authorization_token.authorization = authorization
authorization_token.authorization_code = get_key()
authorization_token.expiry = datetime.now() + timedelta(
seconds=capi.oauth_authorization_token_expiry_time)
authorization_token.refresh_token = get_key()
return authorization_token
def check_authorization(self):
session = Session()
client_id = self.request.form.get("client_id", None)
user = get_login_user()
if client_id:
try:
authorization = session.query(domain.OAuthAuthorization).join(
domain.OAuthApplication).filter(
sa.and_(
domain.OAuthApplication.identifier == client_id,
domain.OAuthAuthorization.user_id ==
user.user_id)).one()
authorization_token = self.get_authorization_token(
authorization)
session.add(authorization_token)
return authorization_token
except NoResultFound:
return None
return None
def setUpWidgets(self, ignore_request=False):
self.widgets = form.setUpWidgets(
self.form_fields,
"",
self.context,
self.request,
data=self.parameters if self.parameters else self.request.form,
ignore_request=ignore_request)
def generate_nonce(self, client_id, auth_time):
data = "{0}:{1}:{2}".format(client_id,
get_login_user().user_id, auth_time)
return hmac.new(capi.oauth_hmac_key, data, hashlib.sha1).hexdigest()
def verify_data(self, action, data):
errors = []
for key, value in self.request.form.iteritems():
data[key] = value
t_delta = timedelta(seconds=capi.oauth_authorization_token_expiry_time)
auth_time = datetime.fromtimestamp(float(data["time"]))
max_time = auth_time + t_delta
if (datetime.now() > max_time):
errors.append(InvalidGrant)
nonce = self.generate_nonce(data["client_id"], data["time"])
if data["nonce"] != nonce:
errors.append(InvalidGrant)
return errors
def handle_failure(self, action, data, errors):
return ErrorPage(self.context, self.request, errors[0])()
def get_redirect_uri(self, authorization_token, state=None):
redirect_uri = "{0}?code={1}".format(
authorization_token.authorization.application.redirection_endpoint,
authorization_token.authorization_code)
if state:
redirect_uri = "{0}&state={1}".format(redirect_uri, state)
return redirect_uri
@form.action(_(u"Authorize application"),
name="authorize",
validator=verify_data,
failure=handle_failure)
def handle_authorize_app(self, action, data):
session = Session()
authorization = domain.OAuthAuthorization()
authorization.user_id = get_login_user().user_id
app = session.query(domain.OAuthApplication).filter(
domain.OAuthApplication.identifier == data["client_id"]).one()
authorization.application_id = app.application_id
authorization.active = True
session.add(authorization)
authorization_token = self.get_authorization_token(authorization)
session.add(authorization_token)
session.flush()
redirect_uri = self.get_redirect_uri(authorization_token,
data["state"])
self.request.response.redirect(redirect_uri, trusted=True)
@form.action(_(u"Cancel"), name="cancel")
def handle_cancel(self, action, data):
session = Session()
app = session.query(domain.OAuthApplication).filter(
domain.OAuthApplication.application_identifier ==
data["client_id"]).one()
error = UnauthorizedClient(app.redirection_endpoint, data["state"])
redirect_error(self.context, self.request, error)
class LoginBase(form.FormBase):
template = NamedTemplate("alchemist.form")
prefix = ""
class DeleteForm(PageForm):
"""Delete-form for Bungeni content.
Confirmation
The user is presented with a confirmation form which details
the items that are going to be deleted.
Subobjects
Recursively, a permission check is carried out for each item
that is going to be deleted. If a permission check fails, an
error message is displayed to the user.
Will redirect back to the container on success.
"""
# zpt
# !+form_template(mr, jul-2010) this is unused here, but needed by
# some adapter of this "object delete" view
form_template = NamedTemplate("alchemist.form")
template = ViewPageTemplateFile("templates/delete.pt")
_next_url = None
form_fields = formlib.form.Fields()
def _can_delete_item(self, action):
return True
def nextURL(self):
return self._next_url
def update(self):
self.subobjects = self.get_subobjects()
super(DeleteForm, self).update()
def get_subobjects(self):
return ()
def delete_subobjects(self):
return 0
@formlib.form.action(_(u"Delete"), condition=_can_delete_item)
def handle_delete(self, action, data):
count = self.delete_subobjects()
container = self.context.__parent__
trusted = removeSecurityProxy(self.context)
session = Session()
session.delete(trusted)
count += 1
try:
session.flush()
except IntegrityError, e:
# this should not happen in production; it's a critical
# error, because the transaction might have failed in the
# second phase of the commit
session.rollback()
log.critical(e)
self.status = _(u"Could not delete item due to "
"database integrity error")
return self.render()
# !+SESSION_CLOSE(taras.sterch, july-2011) there is no need to close the
# session. Transaction manager will take care of this. Hope it does not
# brake anything.
#session.close()
#TODO: check that it is removed from the index!
notify(
ObjectRemovedEvent(self.context,
oldParent=container,
oldName=self.context.__name__))
# we have to switch our context here otherwise the deleted object will
# be merged into the session again and reappear magically
self.context = container
next_url = self.nextURL()
if next_url is None:
next_url = url.absoluteURL(container, self.request) + \
"/?portal_status_message=%d items deleted" % count
self.request.response.redirect(next_url)
class PageForm(BaseForm, formlib.form.PageForm, browser.BungeniBrowserView):
template = NamedTemplate("alchemist.form")
class DynamicFields( object ):
mode = None # required string attribute
template = NamedTemplate('alchemist.form')
form_fields = form.Fields()
def getDomainModel( self ):
return getattr( self.context, 'domain_model', self.context.__class__)
def update( self ):
"""
override update method to setup fields dynamically before widgets are
setup and actions called.
"""
domain_model = self.getDomainModel()
self.form_fields = setUpFields( domain_model, self.mode )
super( DynamicFields, self).update()
setWidgetErrors( self.widgets, self.errors )
@property
def form_name( self ):
# play nice w/ containers or content views, or content
domain_model = getattr( self.context, 'domain_model', None)
if domain_model is None:
domain_model = getattr( self, 'domain_model', None)
if domain_model is None and IAlchemistContent.providedBy( self.context ):
domain_model = self.context.__class__
if domain_model is None:
return self.mode.title()
return "%s %s"%(self.mode.title(), domain_model.__name__)
def splitwidgets( self ):
"""
return two lists of form fields split into two, int overflow into
first column.
"""
# give first and second set of field names
field_count = len( self.form_fields )
first_half_count = math.ceil( field_count / 2.0 )
first_half_widgets, second_half_widgets = [], []
for idx, field in itertools.izip( itertools.count(), self.form_fields ):
if idx < first_half_count:
first_half_widgets.append( self.widgets[ field.__name__ ] )
else:
second_half_widgets.append( self.widgets[ field.__name__ ] )
return first_half_widgets, second_half_widgets
def validateUnique( self, action, data ):
"""
verification method for adding or editing against anything existing
that conflicts with an existing row, as regards unique column constraints.
this is somewhat costly as we basically reinvoke parsing form data twice,
we need to extend zope.formlib to ignore existing values in the data dictionary
to avoid this.
its also costly because we're doing a query per unique column data we find, in
order to unambigously identify the field thats problematic. but presumably those
are very fast due to the unique constraint.
TODO : assumes column == attribute
"""
errors = form.getWidgetsData( self.widgets, self.prefix, data ) + \
form.checkInvariants(self.form_fields, data)
if errors:
return errors
domain_model = removeSecurityProxy( self.getDomainModel() )
# find unique columns in data model.. TODO do this statically
mapper = orm.class_mapper( domain_model )
ucols = list( unique_columns( mapper ) )
errors = []
# query out any existing values with the same unique values,
s = Session()
# find data matching unique columns
for key, col in ucols:
if key in data:
# on edit ignore new value if its the same as the previous value
if isinstance( self.context, domain_model ) \
and data[key] == getattr( self.context, key, None):
continue
value = s.query( domain_model ).filter( col == data[key] ).count()
if not value:
continue
widget = self.widgets[ key ]
error = form.WidgetInputError( widget.name,
widget.label,
u"Duplicate Value for Unique Field" )
widget._error = error
errors.append( error )
if errors:
return tuple(errors)
class OAuthAuthorizeForm(form.FormBase):
form_fields = form.Fields(IOAuthAuthorizeForm)
form_fields["client_id"].custom_widget = widgets.HiddenTextWidget
form_fields["state"].custom_widget = widgets.HiddenTextWidget
form_fields["nonce"].custom_widget = widgets.HiddenTextWidget
form_fields["time"].custom_widget = widgets.HiddenTextWidget
template = NamedTemplate("alchemist.form")
form_name = _("authorise_oauth_application",
default=u"Authorise OAuth Application")
def __init__(self, context, request, parameters={}):
self.parameters = parameters
if self.parameters:
self.parameters["time"] = time.time()
self.parameters["nonce"] = self.generate_nonce(
self.parameters["time"])
self.action_url = "/api/oauth/authorize-form"
super(OAuthAuthorizeForm, self).__init__(context, request)
def setUpWidgets(self, ignore_request=False):
self.widgets = form.setUpWidgets(
self.form_fields, self.prefix, self.context, self.request,
data=self.parameters if self.parameters else self.request.form,
ignore_request=ignore_request
)
def generate_nonce(self, auth_time):
data = "{0}:{1}:{2}".format(
self.parameters["client_id"], get_db_user().user_id, auth_time)
return hmac.new(capi.oauth_hmac_key, data, hashlib.sha1).hexdigest()
def check_authorization(self, action, data):
errors = []
data = self.request.form
if not data.get("form.time", None) or not data.get("form.nonce", None):
errors.append(InvalidRequest)
return errors
max_time = datetime.fromtimestamp(float(data["form.time"])) + \
timedelta(seconds=capi.oauth_authorization_token_expiry_time)
if (datetime.now() > max_time):
errors.append(InvalidGrant)
if data["form.nonce"] != self.generate_nonce(data["form.time"]):
errors.append(InvalidGrant)
return errors
def handle_failure(self, action, data, errors):
return ErrorPage(self.context, self.request, errors[0])()
@form.action(_(u"Authorize application"), name="authorize",
validator=check_authorization, failure=handle_failure)
def handle_authorize_app(self, action, data):
session = Session()
oauth_authorization = domain.OAuthAuthorization()
oauth_authorization.user_id = get_db_user().user_id
app = session.query(domain.OAuthApplication
).filter(domain.OAuthApplication.identifier ==
data["client_id"]
).one()
oauth_authorization.application_id = app.application_id
oauth_authorization.authorization_code = get_key()
oauth_authorization.expiry = datetime.now() + timedelta(
seconds=capi.oauth_authorization_token_expiry_time)
oauth_authorization.active = True
session.add(oauth_authorization)
redirect_uri = "{0}?code={1}".format(
app.redirection_endpoint, oauth_authorization.authorization_code)
if data.get("state", None):
redirect_uri = "{0}&state={1}".format(redirect_uri, data["state"])
self.request.response.redirect(redirect_uri, trusted=True)
@form.action(_(u"Cancel"), name="cancel")
def handle_cancel(self, action, data):
session = Session()
app = session.query(domain.OAuthApplication
).filter(domain.OAuthApplication.application_identifier
== data["client_id"]
).one()
error = UnauthorizedClient(app.redirection_endpoint, data["state"])
redirect_error(self.context, self.request, error)
class ContentViewletManager(manager.ViewletManagerBase):
template = NamedTemplate('alchemist.content')
class AttributesViewViewlet(core.DynamicFields, DisplayFormViewlet):
mode = "view"
template = NamedTemplate('alchemist.subform')
form_name = _(u"General")
class ArchiveDatesForm(form.PageForm):
status = None
class IDateRangeSchema(interface.Interface):
range_start_date = schema.Date(
title=_(u"From"),
description=_(u"Leave blank or set lower limit"),
required=False)
range_end_date = schema.Date(
title=_(u"To"),
description=_(u"Leave blank or set upper limit"),
required=False)
parliament = schema.Choice(
title=_(u"Or select"),
description=_(u"Set date range to that of a given particular parliament"),
vocabulary="bungeni.vocabulary.ParliamentSource",
required=False)
template = NamedTemplate('alchemist.subform')
form_fields = form.Fields(IDateRangeSchema, render_context=True)
form_fields['range_start_date'].custom_widget = DateWidget
form_fields['range_end_date'].custom_widget = DateWidget
form_description = _(u"Filter the archive by date range")
def is_in_parliament(self, context):
parent = context
while not IParliament.providedBy(parent):
parent = getattr(parent, '__parent__', None)
if parent is None:
return False
return True
def get_start_end_restictions(self, context):
parent = context
while not hasattr(parent,'start_date'):
parent = getattr(parent, '__parent__', None)
if parent is None:
return None, None
return getattr(parent, 'start_date', None), getattr(parent, 'end_date', None)
def setUpWidgets(self, ignore_request=False, cookie=None):
if ignore_request is False:
start_date, end_date = get_date_range(self.request)
else:
start_date = end_date = None
context = type("context", (), {
'range_start_date': start_date,
'range_end_date': end_date,
'parliament': None})
self.adapters = {
self.IDateRangeSchema: context,
}
if self.is_in_parliament(self.context):
self.form_fields = self.form_fields.omit('parliament')
self.widgets = form.setUpWidgets(
self.form_fields, self.prefix, self.context, self.request,
form=self, adapters=self.adapters, ignore_request=True)
try:
self.widgets['parliament']._messageNoValue = _(
u"parliament...")
except KeyError:
pass
start, end = self.get_start_end_restictions(self.context)
self.widgets['range_start_date'].set_min_date(start)
self.widgets['range_end_date'].set_min_date(start)
self.widgets['range_start_date'].set_max_date(end)
self.widgets['range_end_date'].set_max_date(end)
@form.action(_(u"Filter"))
def handle_filter(self, action, data):
start_date = data.get('range_start_date')
end_date = data.get('range_end_date')
params = {}
if start_date and end_date:
if start_date > end_date:
self.status = _("Invalid Date Range")
unset_date_range(self.request)
return
start, end = self.get_start_end_restictions(self.context)
if start_date and end:
if start_date > end:
self.status = (_("Start date must be before %s") %
end.strftime("%d %B %Y"))
unset_date_range(self.request)
return
if end_date and start:
if end_date < start:
self.status = (_("End date must be after %s") %
start.strftime("%d %B %Y"))
unset_date_range(self.request)
return
set_date_range(self.request, start_date, end_date)
self.request.response.redirect(
"?portal_status_message=%s" % translate(
_(u"Date range set")))
@form.action(_(u"Clear"))
def handle_clear(self, action, data):
unset_date_range(self.request)
self.request.response.redirect(
"?portal_status_message=%s" % translate(
_(u"Date range cleared")))
class GenerateDebateRecordTakes(BungeniBrowserView, ui.BaseForm):
"""View to generate takes
"""
form_fields = []
template = NamedTemplate("alchemist.subform")
def __init__(self, context, request):
if IDebateTakeContainer.providedBy(context):
self.context = removeSecurityProxy(context).__parent__
else:
self.context = removeSecurityProxy(context)
self.prm = IPrincipalRoleMap(self.context)
self.request = request
#super(GenerateDebateRecordTakes, self).__init__(context, request)
def get_take_duration(self):
return component.getUtility(IDebateRecordConfig).get_take_duration()
def get_transcriber_role(self):
return component.getUtility(IDebateRecordConfig).get_transcriber_role()
def get_transcribers(self):
transcribers = []
transcriber_role = self.get_transcriber_role()
users = common.get_local_users_for_subrole(transcriber_role)
for user in users:
if self.user_is_assigned(user.login, transcriber_role):
transcribers.append(user)
return transcribers
def user_is_assigned(self, user_login, role_id):
if self.prm.getSetting(role_id, user_login) == Allow:
return True
return False
def get_take_name(self, take_count):
take_name_prefix = ""
b_take_count = take_count
while (take_count / 26):
take_count = take_count / 26
take_name_prefix = take_name_prefix + chr(64 + take_count)
return take_name_prefix + chr(65 + (b_take_count % 26))
def has_no_takes(self, action=None):
return False if len(self.context.debate_takes) > 0 else True
@formlib.form.action(label=_("Generate takes"),
name="generate",
condition=has_no_takes)
def handle_generate_takes(self, action, data):
transcribers = self.get_transcribers()
next_url = url.absoluteURL(self.context, self.request)
if not transcribers:
return self.request.response.redirect(next_url + "/takes")
sitting = self.context.sitting
take_time_delta = datetime.timedelta(seconds=self.get_take_duration())
current_end_time = sitting.start_date
current_start_time = sitting.start_date
take_count = 0
session = Session()
while current_end_time < sitting.end_date:
take = domain.DebateTake()
take.debate_record_id = self.context.debate_record_id
take.start_date = current_start_time
if ((current_end_time + take_time_delta) > sitting.end_date):
current_end_time = sitting.end_date
else:
current_end_time = current_end_time + take_time_delta
current_start_time = current_end_time + datetime.timedelta(
seconds=1)
take.end_date = current_end_time
take.transcriber_id = transcribers[take_count %
len(transcribers)].user_id
take.debate_take_name = self.get_take_name(take_count)
take_count = take_count + 1
session.add(take)
session.flush()
return self.request.response.redirect(next_url + "/takes")
class DocumentEditForm(EditForm):
form_fields = Fields(ISimpleDocument)
label = u"Edit document"
template = NamedTemplate('simpledocument.form')
class PageForm(BaseForm, form.PageForm):
template = NamedTemplate('alchemist.form')
class PageForm(BaseForm, formlib.form.PageForm, browser.BungeniBrowserView):
#template = z3evoque.PageViewTemplateFile("form.html#page")
template = NamedTemplate("alchemist.form")
class RestorePassword(form.FormBase):
form_fields = form.Fields(IRestorePasswordForm)
prefix = ""
form_name = _(u"Restore Password")
template = NamedTemplate("alchemist.form")
def __call__(self):
if not IUnauthenticatedPrincipal.providedBy(self.request.principal):
app = getSite()
workspace = app["workspace"]
self.request.response.redirect(
ui_utils.url.absoluteURL(workspace, self.request))
return super(RestorePassword, self).__call__()
@form.action(_(u"Restore"), name="restore")
def handle_restore(self, action, data):
site_url = ui_utils.url.absoluteURL(getSite(), self.request)
login = data.get("login", "")
email = data.get("email", "")
user = None
app = BungeniApp()
settings = EmailSettings(app)
session = Session()
if email:
user = session.query(User).filter(
User.email==email).first()
elif login:
user = session.query(User).filter(
User.login==login).first()
if user:
email = user.email
link = session.query(PasswordRestoreLink).filter(
PasswordRestoreLink.user_id==user.user_id).first()
if link:
if not link.expired():
self.status = _(u"This user's link is still active!")
return
else:
link = PasswordRestoreLink()
link.hash = hashlib.sha224(user.login +
SECRET_KEY +
str(datetime.datetime.now())).hexdigest()
link.expiration_date = datetime.datetime.now() + datetime.timedelta(1)
link.user_id = user.user_id
session.add(link)
mailer = getUtility(ISMTPMailer, name="bungeni.smtp")
self.message = _(u"Restore password link: ")\
+ "%s/reset_password?key=%s" % (site_url, link.hash)
self.message += u"\n\n"
self.message += _(u"This link will expire in 24 hours.")
text = ViewPageTemplateFile("templates/mail.pt")(self)
message = MIMEText(text)
message.set_charset("utf-8")
message["Subject"] = _(u"Bungeni password restoration")
message["From"] = settings.default_sender
mailer.send(settings.default_sender, email, str(message))
self.status = _(u"Email was sent!")
else:
self.status = _(u"User not found!")
class DeleteForm(PageForm):
"""Delete-form for Bungeni content.
Confirmation
The user is presented with a confirmation form which details
the items that are going to be deleted.
Subobjects
Recursively, a permission check is carried out for each item
that is going to be deleted. If a permission check fails, an
error message is displayed to the user.
Will redirect back to the container on success.
"""
form_template = NamedTemplate("alchemist.form")
template = ViewPageTemplateFile("templates/delete.pt")
#template = z3evoque.PageViewTemplateFile("delete.html")
_next_url = None
form_fields = formlib.form.Fields()
def _can_delete_item(self, action):
return True
def nextURL(self):
return self._next_url
def update(self):
self.subobjects = self.get_subobjects()
super(DeleteForm, self).update()
def get_subobjects(self):
return ()
def delete_subobjects(self):
return 0
@formlib.form.action(_(u"Delete"),
name="delete",
condition=_can_delete_item)
def handle_delete(self, action, data):
count = self.delete_subobjects()
container = self.context.__parent__
trusted = removeSecurityProxy(self.context)
session = Session()
session.delete(trusted)
count += 1
try:
session.flush()
except IntegrityError, e:
# this should not happen in production; it's a critical
# error, because the transaction might have failed in the
# second phase of the commit
session.rollback()
log.critical(e)
self.status = _(
"Could not delete item due to database integrity error. "
"You may wish to try deleting any related sub-records first?")
return self.render()
#TODO: check that it is removed from the index!
notify(
ObjectRemovedEvent(self.context,
oldParent=container,
oldName=self.context.__name__))
# we have to switch our context here otherwise the deleted object will
# be merged into the session again and reappear magically
self.context = container
cascade_modifications(container)
next_url = self.nextURL()
if next_url is None:
next_url = url.absoluteURL(container, self.request) + \
"/?portal_status_message=%d items deleted" % count
if self.is_headless:
log.info("Deleting in headless mode - No redirection")
else:
self.request.response.redirect(next_url)
class Profile(BaseForm):
form_fields = form.Fields(IProfileForm)
form_fields["gender"].custom_widget=widgets.CustomRadioWidget
form_fields["date_of_birth"].custom_widget=widgets.DateWidget
form_fields["description"].custom_widget=widgets.RichTextEditor
form_fields["image"].custom_widget=widgets.ImageInputWidget
prefix = ""
form_name = _(u"Profile")
# !+ only used here [ bungeni.ui.login.Login ] ?
template = NamedTemplate("alchemist.form")
def __init__(self, *args, **kwargs):
super(Profile, self).__init__(*args, **kwargs)
self.user = get_db_user(self.context)
self.context = self.user
def __call__(self):
if IUnauthenticatedPrincipal.providedBy(self.request.principal):
self.request.response.redirect(
ui_utils.url.absoluteURL(
getSite(), self.request)+"/login"
)
return super(Profile, self).__call__()
def setUpWidgets(self, ignore_request=False):
super(Profile, self).setUpWidgets(ignore_request=ignore_request)
for widget in self.widgets:
name = widget.name
if self.request.get(name,None) is None:
self.widgets[name].setRenderedValue(
getattr(self.user, name, None))
else:
self.widgets[name].setRenderedValue(
self.request.get(name,None))
if name == "gender":
self.widgets[name].setRenderedValue(
self.request.get(name)[0])
def _do_save(self, data):
email = data.get("email","")
first_name = data.get("first_name","")
last_name = data.get("last_name","")
middle_name = data.get("middle_name","")
description = data.get("description","")
gender = data.get("gender","")
image = data.get("image","")
date_of_birth = data.get("date_of_birth","")
birth_nationality = data.get("birth_nationality","")
birth_country = data.get("birth_country","")
current_nationality = data.get("current_nationality","")
if email:
self.user.email = email
if first_name:
self.user.first_name = first_name
if last_name:
self.user.last_name = last_name
if middle_name:
self.user.middle_name = middle_name
if description:
self.user.description = description
if gender:
self.user.gender = gender
if date_of_birth:
self.user.date_of_birth = date_of_birth
if image:
self.user.image = image
if birth_nationality:
self.user.birth_nationality = birth_nationality
if birth_country:
self.user.birth_country = birth_country
if current_nationality:
self.user.current_nationality = current_nationality
self.status = _("Profile data updated")
@form.action(_(u"Save"), name="save",
condition=form.haveInputWidgets)
def handle_edit_save(self, action, data):
"""Saves the document and goes back to edit page"""
self._do_save(data)
@form.action(_(u"Save and view"), name="save_and_view",
condition=form.haveInputWidgets)
def handle_edit_save_and_view(self, action, data):
"""Saves the document and redirects to its view page"""
self._do_save(data)
if not self._next_url:
self._next_url = ui_utils.url.absoluteURL(self.context, self.request) + \
"?portal_status_message= Saved"
self.request.response.redirect(self._next_url)
@form.action(_(u"Cancel"), name="cancel",
validator=ui.null_validator)
def handle_edit_cancel(self, action, data):
"""Cancelling redirects to the listing."""
if not self._next_url:
self._next_url = ui_utils.url.absoluteURL(self.context, self.request)
self.request.response.redirect(self._next_url)
class AttributesEditViewlet(ui.core.DynamicFields, ui.viewlet.EditFormViewlet):
mode = "edit"
template = NamedTemplate('alchemist.subform')
form_name = _(u"General")
class Profile(form.FormBase):
form_fields = form.Fields(IProfileForm)
form_fields["gender"].custom_widget = widgets.CustomRadioWidget
form_fields["date_of_birth"].custom_widget = widgets.DateWidget
form_fields["description"].custom_widget = widgets.RichTextEditor
form_fields["image"].custom_widget = widgets.ImageInputWidget
prefix = ""
form_name = _(u"Profile")
# !+ only used here [ bungeni.ui.login.Login ] ?
template = NamedTemplate("alchemist.form")
def __init__(self, *args, **kwargs):
super(Profile, self).__init__(*args, **kwargs)
self.session = Session()
user_id = get_db_user_id(self.context)
self.user = self.session.query(User)\
.filter(User.user_id==user_id).first()
def __call__(self):
if IUnauthenticatedPrincipal.providedBy(self.request.principal):
self.request.response.redirect(
ui_utils.url.absoluteURL(getSite(), self.request) + "/login")
return super(Profile, self).__call__()
def setUpWidgets(self, ignore_request=False):
super(Profile, self).setUpWidgets(ignore_request=ignore_request)
self.widgets["email"].setRenderedValue(self.user.email)
self.widgets["first_name"].setRenderedValue(self.user.first_name)
self.widgets["last_name"].setRenderedValue(self.user.last_name)
self.widgets["middle_name"].setRenderedValue(self.user.middle_name)
self.widgets["description"].setRenderedValue(self.user.description)
self.widgets["gender"].setRenderedValue(self.user.gender)
self.widgets["image"].setRenderedValue(self.user.image)
self.widgets["date_of_birth"].setRenderedValue(self.user.date_of_birth)
self.widgets["birth_nationality"].setRenderedValue(
self.user.birth_nationality)
self.widgets["birth_country"].setRenderedValue(self.user.birth_country)
self.widgets["current_nationality"].setRenderedValue(
self.user.current_nationality)
@form.action(_(u"Save"))
def save_profile(self, action, data):
email = data.get("email", "")
first_name = data.get("first_name", "")
last_name = data.get("last_name", "")
middle_name = data.get("middle_name", "")
description = data.get("description", "")
gender = data.get("gender", "")
image = data.get("image", "")
date_of_birth = data.get("date_of_birth", "")
birth_nationality = data.get("birth_nationality", "")
birth_country = data.get("birth_country", "")
current_nationality = data.get("current_nationality", "")
if email:
users = self.session.query(User).filter(User.email == email)
if (users.count() == 1 and users.first().user_id == self.user.user_id) or\
users.count() == 0:
self.user.email = email
else:
self.status = _("Email already taken!")
return
if first_name:
self.user.first_name = first_name
if last_name:
self.user.last_name = last_name
if middle_name:
self.user.middle_name = middle_name
if description:
self.user.description = description
if gender:
self.user.gender = gender
if date_of_birth:
self.user.date_of_birth = date_of_birth
if image:
self.user.image = image
if birth_nationality:
self.user.birth_nationality = birth_nationality
if birth_country:
self.user.birth_country = birth_country
if current_nationality:
self.user.current_nationality = current_nationality
self.status = _("Profile data updated")
