def inline_add_form(api, content_type, bind_data):
""" Expects the context for the add form to be the current requests context.
This is only used within the agenda item view currently.
"""
tag = api.request.GET.get('tag', '')
schema_name = api.get_schema_name(content_type, 'add')
schema = createSchema(schema_name, bind = bind_data)
query = {'content_type': content_type, 'tag': tag}
url = api.request.resource_url(api.context, '_inline_form', query = query)
return Form(schema, action = url, buttons = (button_add,), use_ajax = True)
def form_view(request):
schema = Schema()
form = Form(schema)
if 'submit' in request.POST:
controls = request.POST.items()
try:
appstruct = form.validate(controls)
except ValidationFailure as e:
return {'form': form}
return {'form': form}
def generate_labels_form(self, formid="deform_tags"):
"""This helper code generates the form that will be used to add
and edit job tags/labels based on the schema of the form.
"""
update_button = Button(name='update_labels',
title='Update',
css_class='btn btn-success')
return Form(schema=LabelsSchema(),
buttons=(update_button, ),
formid=formid)
def get_form(request, class_form):
schema = class_form(validator=form_validator)
schema = schema.bind(
daftar_status=STATUS,
daftar_wajibpajak=daftar_wajibpajak(),
daftar_unit=daftar_unit(),
daftar_objekpajak=daftar_objekpajak(),
)
schema.request = request
return Form(schema, buttons=('simpan', 'batal'))
def _get_field(name, renderer):
from deform import Form
from colanderalchemy import SQLAlchemySchemaNode
form = Form(SQLAlchemySchemaNode(Person), renderer=renderer)
for field in form.children:
if field.name == name:
return field
raise RuntimeError('Field not found')
def generate_caption_form(self, formid="deform_caption"):
"""This helper code generates the form that will be used to add
and edit job captions based on the schema of the form.
"""
update_button = Button(name='update_caption',
title='Update',
css_class='btn btn-success')
return Form(schema=CaptionSchema(),
buttons=(update_button, ),
formid=formid)
def contact(self):
""" Contact moderators of the meeting
"""
recipients = []
for userid in find_role_userids(self.context, ROLE_MODERATOR):
user = self.api.get_user(userid)
email = user.get_field_value('email')
if email:
recipients.append(email)
if not recipients:
for userid in find_authorized_userids(self.context,
(MODERATE_MEETING, )):
user = self.api.get_user(userid)
email = user.get_field_value('email')
if email:
recipients.append(email)
schema = createSchema('ContactSchema').bind(context=self.context,
request=self.request,
api=self.api)
form = Form(schema, buttons=(button_send, ))
self.api.register_form_resources(form)
post = self.request.POST
if self.request.method == 'POST':
controls = post.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
self.response['form'] = e.render()
return self.response
if appstruct.get('email', None):
sender = appstruct['email']
if self.api.user_profile:
sender += " <%s>" % self.api.user_profile.title
else:
sender = None
response = {
'api': self.api,
'meeting': self.context,
'name': appstruct['name'],
'email': appstruct['email'],
'subject': appstruct['subject'],
'message': appstruct['message'],
}
body_html = render('templates/email/help_contact.pt',
response,
request=self.request)
subject = "[%s] %s" % (self.context.title, appstruct['subject'])
send_email(subject,
recipients,
body_html,
sender=sender,
request=self.request)
self.api.flash_messages.add(_(u"Message sent to the moderators"))
url = self.request.resource_url(self.context)
return HTTPFound(location=url)
def view(self):
# Get LDAP settings
ldap_settings = self.request.db.ldap.find_one()
if ldap_settings is None:
ldap_settings = dict()
# Generate form
from phoenix.settings.schema import LdapSchema
ldap_form = Form(schema=LdapSchema().bind(request=self.request), buttons=('submit',), formid='deform')
if 'submit' in self.request.params:
check_csrf_token(self.request)
try:
# Validate form
appstruct = ldap_form.validate(list(self.request.params.items()))
except ValidationFailure as e:
LOGGER.exception('Validation failed!')
return dict(title='LDAP Settings', form=e.render())
else:
# Update LDAP settings
ldap_settings['server'] = appstruct['server']
ldap_settings['use_tls'] = appstruct['use_tls']
ldap_settings['bind'] = appstruct['bind']
ldap_settings['passwd'] = appstruct['passwd']
ldap_settings['base_dn'] = appstruct['base_dn']
ldap_settings['filter_tmpl'] = appstruct['filter_tmpl']
ldap_settings['scope'] = appstruct['scope']
# Optional:
ldap_settings['name'] = appstruct['name']
ldap_settings['email'] = appstruct['email']
self.request.db.ldap.save(ldap_settings)
import ldap
if ldap_settings['scope'] == 'ONELEVEL':
ldap_scope = ldap.SCOPE_ONELEVEL
else:
ldap_scope = ldap.SCOPE_SUBTREE
from pyramid.config import Configurator
config = Configurator(registry=self.request.registry)
config.ldap_setup(
ldap_settings['server'],
bind=ldap_settings['bind'],
passwd=ldap_settings['passwd'],
use_tls=ldap_settings['use_tls'])
config.ldap_set_login_query(
base_dn=ldap_settings['base_dn'],
filter_tmpl=ldap_settings['filter_tmpl'],
scope=ldap_scope)
config.commit()
self.session.flash('Successfully updated LDAP settings!', queue='success')
# Display form
return dict(title='LDAP Settings', form=ldap_form.render(ldap_settings))
def make_password_reset_form(request):
schema = PasswordReset()
if request:
schema = PasswordReset().bind(request=request)
password_reset_form = Form(schema,
bootstrap_form_style='form-vertical',
buttons=(Button('submit',
title='Reset Password'), ),
resource_registry=password_registry,
renderer=renderer)
return password_reset_form
def get_expense_id_form(counter):
"""
Return a form for expense export by id
:param counter: the iterator used to insert various forms in the same page
"""
schema = ExpenseIdSchema(title=u"Exporter une notes de frais depuis \
un identifiant")
return Form(schema=schema,
buttons=(EXPORT_BTN, ),
formid="expense_id_form",
counter=counter)
def get_from_invoice_number_form(counter, request):
"""
Return the export criteria form used to export from a given invoice
"""
schema = FromInvoiceNumberSchema(
title=u"Exporter les factures à partir d'un numéro")
schema = schema.bind(request=request)
return Form(schema=schema,
buttons=(EXPORT_BTN, ),
formid='from_invoice_number_form',
counter=counter)
def make_password_change_form(request, admin_change=False):
schema = PasswordChange()
if admin_change:
del schema['password']
password_reset_form = Form(schema=schema.bind(request=request),
bootstrap_form_style='form-vertical',
buttons=(Button('submit',
title='Change Password'), ),
resource_registry=password_registry,
renderer=renderer)
return password_reset_form
def get_year_form(self):
"""
Return the year selection form
"""
schema = self.year_form_schema.bind(request=self.request)
form = Form(schema=schema,
buttons=(),
method='GET',
formid='year_form')
form.set_appstruct(self.submit_year())
return form
def get_all_form(counter, title=u"Exporter les factures non exportées"):
"""
Return a void form used to export all non-exported documents
"""
schema = AllSchema(title=title)
return Form(
schema=schema,
buttons=(EXPORT_BTN, ),
formid='all_form',
counter=counter,
)
def make_disable_user_form(request):
schema = DisableUser()
# This form will be on a page with multiple forms,
# so we have to set the formid attribute for the ajax
# stuff to work.
disable_user_form = Form(
schema=schema.bind(request=request),
buttons=(Button('submit', title='Yes'), Button('cancel', title='No')),
formid='disable-form',
)
return disable_user_form
def get_invoice_pdf_export_form(request):
"""
Return the form used to search for invoices that will be exported
"""
schema = pdfexportSchema.bind(request=request)
action = request.route_path(
"invoices",
_query=dict(action="export_pdf"),
)
query_form = Form(schema, buttons=(submit_btn, ), action=action)
return query_form
def get_expense_form(request):
"""
Return a form for expense export
"""
schema = ExpenseSchema(title=u"Exporter les notes de dépense")
schema = schema.bind(request=request)
return Form(
schema=schema,
buttons=(EXPORT_BTN, ),
formid="expense_form",
)
def get_period_form(title=u"Exporter les factures sur une période donnée"):
"""
Return the period search form
"""
schema = periodSchema
schema.title = title
return Form(
schema=schema,
buttons=(EXPORT_BTN, ),
formid='period_form',
)
def contact(request):
button1 = Button('submit', _('Send message'))
button1.css_class = 'btn-primary'
button2 = Button('cancel', _('Cancel'))
button2.css_class = 'btn-default'
form = Form(ContactSchema(), buttons=(button1, button2))
if 'submit' in request.POST:
controls = request.POST.items()
try:
appstruct = form.validate(controls)
except ValidationFailure as e:
return {'form': e.render()}
context = {'link': request.route_url('contact')}
context.update(appstruct)
subject = ("%s sent a message from Yith's contact form" %
appstruct['name'])
result = send_email_to_admins(
request,
'yithlibraryserver:templates/email_contact',
context,
subject,
extra_headers={'Reply-To': appstruct['email']},
)
if result is None:
log.error(
'%s <%s> tried to send a message from the contact form but no '
'admin emails were configured. Message: %s' % (
appstruct['name'],
appstruct['email'],
appstruct['message'],
))
request.session.flash(
_('Thank you very much for sharing your opinion'),
'info',
)
return HTTPFound(location=request.route_path('home'))
elif 'cancel' in request.POST:
return HTTPFound(location=request.route_path('home'))
initial = {}
if request.user is not None:
initial['name'] = request.user.first_name
if request.user.email_verified:
initial['email'] = request.user.email
return {'form': form.render(initial)}
def ajax_set_groups(self):
schema = createSchema('PermissionsSchema')
add_csrf_token(self.context, self.request, schema)
schema = schema.bind(context=self.context,
request=self.request,
api=self.api)
form = Form(schema, buttons=('save', 'cancel'))
controls = self.request.POST.items()
appstruct = form.validate(controls)
#FIXME: Handle error some way, and return a proper response
self.context.set_security(appstruct['userids_and_groups'])
return Response() # i.e. 200 ok
def edit_slideshow(request):
context = request.context
form = Form(schema.Slideshow(), buttons=('submit', ))
appstruct = {
'name':
context.name,
'slides': [
dict(shard=slide.shard_id, duration=slide.duration)
for slide in context.slides
]
}
return {'form': form.render(appstruct), 'title': u'Edit Slideshow'}
def get_form(config,mwf):
from nipype.interfaces.traits_extension import isdefined
if not isdefined(mwf.html_view):
schema = colander.Schema()
all_traits = config.trait_names()
all_traits.remove('trait_added')
all_traits.remove('trait_modified')
for tr in all_traits:
_type = type(config.trait(tr).trait_type)
col_type = getNode(_type,tr,config)
schema.add(col_type)
form = Form(schema,buttons = ('submit',),action='')
return form.render(appstruct=config.get())
else:
form = Form(mwf.html_view(),buttons = ('submit',),action='')
return form.render()
def get_invoice_number_form(counter, request, title=u"Exporter une facture"):
"""
Return the search form used to search invoices by number+year
"""
schema = InvoiceNumberSchema(title=title)
schema = schema.bind(request=request)
return Form(
schema=schema,
buttons=(EXPORT_BTN, ),
formid='invoice_number_form',
counter=counter,
)
def view_delete(request):
q = query_id(request)
row = q.first()
a = row.id
x = row.approval_level
if not row:
return id_not_found(request)
if x == 1:
request.session.flash(
'Data tidak dapat dihapus, karena sudah masuk di Menu Approval.',
'error')
return route_list(request)
if x == 2:
request.session.flash(
'Data tidak dapat dihapus, karena sudah disetujui.', 'error')
return route_list(request)
if row.disabled:
request.session.flash(
'Data tidak dapat dihapus, karena sudah masuk di Menu Approval.',
'error')
return route_list(request)
if row.status_dlv:
request.session.flash(
'Data tidak dapat dihapus, karena sudah masuk di Menu Pengiriman Gudang.',
'error')
return route_list(request)
# Seleksi untuk di menu Approval
r = DBSession.query(ProductReqAppr).filter(
ProductReqAppr.product_request_id == a).first()
if r:
request.session.flash(
'Hapus dahulu data rencana yang sudah pernah dibuat di Menu Approval.',
'error')
return route_list(request)
# Seleksi untuk mengecek item
i = DBSession.query(ProductRequestItem).filter(
ProductRequestItem.product_request_id == a).first()
if i:
request.session.flash('Hapus dahulu item produk / barang.', 'error')
return route_list(request)
form = Form(colander.Schema(), buttons=('hapus', 'batal'))
if request.POST:
if 'hapus' in request.POST:
msg = 'Order ID %d sudah dihapus.' % (row.id)
q.delete()
DBSession.flush()
request.session.flash(msg)
return route_list(request)
return dict(row=row, form=form.render())
def view_contactform(context, request):
locale_name = get_locale_name(request)
tmpstore = FileUploadTempStore(request)
def file_size_limit(node, value):
value['fp'].seek(0, 2)
size = value['fp'].tell()
value['fp'].seek(0)
max_size = 10
if size > max_size * 1024 * 1024:
msg = _('Maximum file size: ${size}MB', mapping={'size': max_size})
raise colander.Invalid(node, msg)
def maybe_show_attachment(node, kw):
if kw.get('maybe_show_attachment', True) is False:
del node['attachment']
class SubmissionSchema(colander.MappingSchema):
name = colander.SchemaNode(colander.String(), title=_("Full Name"))
sender = colander.SchemaNode(colander.String(),
validator=colander.Email(),
title=_("E-Mail Address"))
subject = colander.SchemaNode(colander.String(), title=_("Subject"))
content = colander.SchemaNode(colander.String(),
widget=TextAreaWidget(cols=40, rows=5),
title=_("Your message"))
attachment = colander.SchemaNode(
FileData(),
title=_('Attachment'),
widget=FileUploadWidget(tmpstore),
validator=file_size_limit,
missing=None,
)
_LOCALE_ = colander.SchemaNode(colander.String(),
widget=HiddenWidget(),
default=locale_name)
schema = SubmissionSchema(after_bind=maybe_show_attachment)
schema = schema.bind(maybe_show_attachment=context.show_attachment)
form = Form(schema, buttons=[Button('submit', _('Submit'))])
appstruct = None
rendered_form = None
if 'submit' in request.POST:
controls = request.POST.items()
try:
appstruct = form.validate(controls)
mail_submission(context, request, appstruct)
except ValidationFailure, e:
appstruct = None
rendered_form = e.render()
def item_new():
if 'cancel' in request.form:
return redirect(url_for('.item_list'))
item_new_schema = ItemNewSchema()
item_new_form = Form(
item_new_schema,
action=url_for('.item_new'),
buttons=get_form_buttons()
)
if 'submit' in request.form:
print request.form
try:
appstruct = item_new_form.validate(request.form.items())
except ValidationFailure as e:
current_app.logger.warning(e.error)
template_context = {'item_new_form': item_new_form}
return render_template(ITEM_NEW_TEMPLATE, **template_context)
new_item = Item()
for key in appstruct:
if hasattr(new_item, key):
if appstruct[key] == colander.null:
setattr(new_item, key, None)
else:
setattr(new_item, key, appstruct[key])
Session.add(new_item)
Session.flush()
clients = get_client_list()
client_items_to_add = []
for client in clients:
client_item = Session.query(ClientItem)\
.filter(ClientItem.client_id == client.id,
ClientItem.item_id == new_item.id,
ClientItem.deleted == False).first()
if not client_item:
client_item = ClientItem(client.id, new_item.id, new_item.price)
client_items_to_add.append(client_item)
if client_items_to_add:
Session.add_all(client_items_to_add)
Session.flush()
flash(u'Uspješno ste dodali novi artikl', 'success')
return redirect(url_for('.item_list'))
template_context = {
'page_title': u'Novi artikl',
'item_new_form': item_new_form
}
return render_template(ITEM_NEW_TEMPLATE, **template_context)
def add_form(self):
content_type = self.request.params.get('content_type')
tag = self.request.GET.get('tag', None)
#Permission check
add_permission = self.api.content_types_add_perm(content_type)
if not has_permission(add_permission, self.context, self.request):
raise HTTPForbidden(
"You're not allowed to add '%s' in this context." %
content_type)
factory = self.api.get_content_factory(content_type)
schema_name = self.api.get_schema_name(content_type, 'add')
schema = createSchema(schema_name).bind(context=self.context,
request=self.request,
api=self.api)
form = Form(schema, buttons=(button_add, button_cancel))
self.api.register_form_resources(form)
if content_type == 'AgendaItem':
self.response['tabs'] = self.api.render_single_view_component(
self.context, self.request, 'tabs', 'manage_agenda')
post = self.request.POST
if 'add' in post:
controls = post.items()
try:
#appstruct is deforms convention. It will be the submitted data in a dict.
appstruct = form.validate(controls)
except ValidationFailure, e:
self.response['form'] = e.render()
return self.response
kwargs = {}
kwargs.update(appstruct)
if self.api.userid:
kwargs['creators'] = [self.api.userid]
obj = createContent(content_type, **kwargs)
name = self.generate_slug(obj.title)
self.context[name] = obj
self.api.flash_messages.add(_(u"Successfully added"))
#Success, redirect
url = self.request.resource_url(obj)
#Polls might have a special redirect action if the poll plugin has a settings schema:
if content_type == 'Poll':
if obj.get_poll_plugin().get_settings_schema() is not None:
url += 'poll_config'
else:
url = self.request.resource_url(obj.__parent__,
anchor=obj.uid)
msg = _(
u"private_poll_info",
default=
u"The poll is created in private state, to show it the participants you have to change the state to upcoming."
)
self.api.flash_messages.add(msg)
return HTTPFound(location=url)
def support(self):
""" Support form - requires support email to be set!
"""
support_email = self.api.root.get_field_value('support_email', None)
if not support_email:
self.api.flash_messages.add(
_(u"No support email set for this site. Form won't work!"))
url = self.request.resource_url(self.context)
return HTTPFound(location=url)
schema = createSchema('SupportSchema').bind(context=self.context,
request=self.request,
api=self.api)
form = Form(schema,
action=self.request.resource_url(self.context, 'support'),
buttons=(button_send, ))
self.api.register_form_resources(form)
post = self.request.POST
if self.request.method == 'POST':
controls = post.items()
try:
appstruct = form.validate(controls)
except ValidationFailure, e:
self.response['form'] = e.render()
return self.response
sender = appstruct['email'] and appstruct[
'email'] or "VoteIT <*****@*****.**>"
response = {
'api': self.api,
'meeting': self.api.meeting,
'name': appstruct['name'],
'email': appstruct['email'],
'subject': appstruct['subject'],
'message': appstruct['message'],
'meeting_title': appstruct.get('meeting_title', ''),
}
body_html = render('templates/email/support.pt',
response,
request=self.request)
title = "%s %s" % (self.api.root.get_field_value(
'site_title', u"VoteIT"), self.api.translate(_(u"Support")))
subject = "[%s] | %s" % (title, appstruct['subject'])
msg = Message(subject=subject,
sender=sender and sender or None,
recipients=(support_email, ),
html=body_html)
mailer = get_mailer(self.request)
mailer.send(msg)
self.api.flash_messages.add(_(u"Support request sent!"))
url = self.request.resource_url(self.context)
return HTTPFound(location=url)
def account_view(self):
"""This is the settings form for the user. The first time a
user logs in, they are taken here so we can get their first and
last name.
"""
# Special case when the db was blown away
if self.user_id is not None and self.user is None:
return self.logout()
section_name = 'account'
schema = SettingsSchema()
form = Form(schema, buttons=('submit', ))
css_resources, js_resources = self.form_resources(form)
if 'submit' in self.request.POST:
controls = self.request.POST.items()
try:
form.validate(controls)
except ValidationFailure as e:
msg = 'There was an error saving your settings.'
self.request.session.flash(msg, queue='error')
return {
'form': e.render(),
'css_resources': css_resources,
'js_resources': js_resources,
'section': section_name,
}
values = parse(self.request.params.items())
# Update the user
with transaction.manager:
self.user.first_name = values.get('first_name', u'')
self.user.last_name = values.get('last_name', u'')
self.user.time_zone = values.get('time_zone', u'US/Eastern')
DBSession.add(self.user)
self.request.session.flash(
'Settings updated successfully',
queue='success',
)
return HTTPFound('/list')
# Get existing values
if self.user is not None:
appstruct = dict(
first_name=self.user.first_name,
last_name=self.user.last_name,
time_zone=self.user.time_zone,
)
else:
appstruct = {}
return {
'form': form.render(appstruct),
'css_resources': css_resources,
'js_resources': js_resources,
'section': section_name,
}
def view_delete(request):
q = query_id(request)
row = q.first()
if not row:
return id_not_found(request)
if row.status_invoice:
request.session.flash('Data sudah masuk di No Bayar', 'error')
return route_list(request)
if row.arsspds:
form = Form(colander.Schema(), buttons=('cancel', ))
else:
form = Form(colander.Schema(), buttons=('delete', 'cancel'))
if request.POST:
if 'delete' in request.POST:
msg = 'No Bayar ID %d %s sudah dihapus.' % (row.id, row.kode)
q.delete()
DBSession.flush()
request.session.flash(msg)
return route_list(request)
return dict(row=row, form=form.render())
