def getWidgetDocument(self): """ Make a LiveForm with one of each kind of input, except for radio buttons, since with the current liveform support for them it's difficult to use them with a single form, and it's not so important to do anything else right now """ f = liveform.LiveForm( self.submit, (liveform.ChoiceParameter('choice', (('0', 0, True), ('1', 1, False))), liveform.ChoiceParameter('choiceMult', (('0', 0, True), ('1', 1, True), ('2', 2, False), ('3', 3, False)), multiple=True), liveform.Parameter( 'text', liveform.TEXT_INPUT, unicode, default=u'hello world'), liveform.Parameter('passwd', liveform.PASSWORD_INPUT, unicode, default=u'secret key'), liveform.Parameter('textArea', liveform.TEXTAREA_INPUT, unicode, default=u'hello world 2'), liveform.Parameter( 'checkbox', liveform.CHECKBOX_INPUT, bool, default=True))) f.setFragmentParent(self) return f
def productForm(self, request, tag): """ Render a L{liveform.LiveForm} -- the main purpose of this fragment -- which will allow the administrator to endow or deprive existing users using Products. """ def makeRemover(i): def remover(s3lected): if s3lected: return self.products[i] return None return remover f = liveform.LiveForm( self._endow, [liveform.Parameter( 'products' + str(i), liveform.FORM_INPUT, liveform.LiveForm( makeRemover(i), [liveform.Parameter( 's3lected', liveform.RADIO_INPUT, bool, repr(p), )], '', ), ) for (i, p) in enumerate(self.products)], self.which.capitalize() + u' ' + self.username) f.setFragmentParent(self) return f
def render_addGrabberForm(self, ctx, data): f = liveform.LiveForm( self.addGrabber, [ liveform.Parameter('domain', liveform.TEXT_INPUT, unicode, u'Domain', u'The domain which hosts the account.'), liveform.Parameter( 'username', liveform.TEXT_INPUT, unicode, u'Username', u'The username portion of the address from which to retrieve messages.' ), liveform.Parameter('password1', liveform.PASSWORD_INPUT, unicode, u'Password', u'The password for the remote account.'), liveform.Parameter('password2', liveform.PASSWORD_INPUT, unicode, u'Repeat Password'), # Along with the above, this might be useful if we had an IMAP grabber. # liveform.Parameter('protocol', # liveform.Choice(grabberTypes.keys()), # lambda value: grabberTypes[value], # u'Super secret computer science stuff', # 'POP3'), liveform.Parameter('ssl', liveform.CHECKBOX_INPUT, bool, u'Use SSL to fetch messages') ], description='Add Grabber') f.jsClass = u'Quotient.Grabber.AddGrabberFormWidget' f.setFragmentParent(self) f.docFactory = webtheme.getLoader('liveform-compact') return ctx.tag[f]
def getWidgetDocument(self): """ Make a nested form """ f = liveform.LiveForm(lambda **k: None, (liveform.Parameter( 'inner-form', liveform.FORM_INPUT, liveform.LiveForm(lambda **k: None, (liveform.Parameter( 'inner-parameter', liveform.TEXT_INPUT, unicode, ''), ), ())), )) f.setFragmentParent(self) return f
def __init__(self, organizer): self.organizer = organizer liveform.LiveForm.__init__( self, self.addPerson, (liveform.Parameter( 'nickname', liveform.TEXT_INPUT, people._normalizeWhitespace, 'Name'), liveform.Parameter( 'email', liveform.TEXT_INPUT, people._normalizeWhitespace, 'Email')), description=u'Add Person')
def __init__(self, uis): self.userInfoSignup = uis self.templateResolver = ITemplateNameResolver(uis.store) super(ValidatingSignupForm, self).__init__(uis.createUser, [ liveform.Parameter(pname, liveform.TEXT_INPUT, unicode) for pname in self._parameterNames ])
def __init__(self, blogPost): super(BlogPostBlurbEditor, self).__init__( lambda *a, **k: blogPost.edit(newAuthor=blogPost.author, *a, **k), (liveform.Parameter( 'newTitle', liveform.TEXT_INPUT, unicode), liveform.Parameter( 'newBody', liveform.TEXT_INPUT, unicode), liveform.Parameter( 'newTags', liveform.TEXT_INPUT, parseTags))) self.blogPost = blogPost
def render_placeCall(self, ctx, data): lf = liveform.LiveForm(self.original.placeCall, [ liveform.Parameter("target", liveform.TEXT_INPUT, self.parseURLorPhoneNum, "Place call:") ]) lf.setFragmentParent(self) return lf
def makeProductPicker(self): """ Make a LiveForm with radio buttons for each Product in the store. """ productPicker = liveform.LiveForm(self.coerceProduct, [ liveform.Parameter( str(id(product)), liveform.FORM_INPUT, liveform.LiveForm( lambda selectedProduct, product=product: selectedProduct and product, [ liveform.Parameter('selectedProduct', liveform.RADIO_INPUT, bool, repr(product)) ])) for product in self.original.store.parent.query(Product) ], u"Product to Install") return productPicker
def __init__(self, page, hyperbola): super(BlogAddingFragment, self).__init__( hyperbola.createBlog, [liveform.Parameter( 'title', liveform.TEXT_INPUT, unicode, "A title for your blog", "A Blog"), liveform.Parameter( 'description', liveform.TEXT_INPUT, unicode, "A description of your blog", "A Blog that I write")]) self.setFragmentParent(page) self.hyperbola = hyperbola _docFactorify(self)
def render_altcontactForm(self, ctx, data): lf = liveform.LiveForm(self.setAltContact, [ liveform.Parameter( "altcontact", liveform.TEXT_INPUT, self.parseURLorPhoneNum, "An alternate SIP URL or phone number to forward calls to when you are not registered", "") ], "Set") lf.setFragmentParent(self) return lf
def getWidgetDocument(self): f = liveform.LiveForm(self.submit, [ liveform.Parameter('argument', liveform.TEXTAREA_INPUT, unicode, 'A text area: ', default=self.defaultText) ]) f.setFragmentParent(self) return f
def getWidgetDocument(self): f = liveform.LiveForm(self.submit, [ liveform.Parameter('argument', liveform.TEXT_INPUT, unicode, 'A text input field: ', default=u'hello world') ]) f.setFragmentParent(self) return f
def addAddressForm(self, req, tag): """ @return: an L{xmantissa.liveform.LiveForm} instance which allows users to add from addresses """ def makeRequiredCoercer(paramName, coerce=lambda v: v): def notEmpty(value): if not value: raise liveform.InvalidInput('value required for ' + paramName) return coerce(value) return notEmpty def textParam(name, label, *a): return liveform.Parameter(name, liveform.TEXT_INPUT, makeRequiredCoercer(name), label, *a) # ideally we would only show the "address" input by default and have a # "SMTP Info" disclosure link which exposes the rest of them lf = liveform.LiveForm( self.addAddress, (textParam('address', 'Email Address'), textParam('smtpHost', 'SMTP Host'), liveform.Parameter( 'smtpPort', liveform.TEXT_INPUT, makeRequiredCoercer('smtpPort', int), 'SMTP Port', default=25), textParam('smtpUsername', 'SMTP Username'), liveform.Parameter('smtpPassword', liveform.PASSWORD_INPUT, makeRequiredCoercer('smtpPassword'), 'SMTP Password'), liveform.Parameter('default', liveform.CHECKBOX_INPUT, bool, 'Default?', 'Use this as default from address')), description='Add From Address') lf.jsClass = u'Quotient.Compose.AddAddressFormWidget' lf.docFactory = getLoader('liveform-compact') lf.setFragmentParent(self) return lf
def __init__(self, composer, message): """ @type composer: L{Composer} @param message: the message being redirected @type message: L{Message} """ self.composer = composer self.message = message self.translator = ixmantissa.IWebTranslator(composer.store) super(RedirectingComposeFragment, self).__init__( callable=self.redirect, parameters=(liveform.Parameter(name='fromAddress', type=liveform.TEXT_INPUT, coercer=self.translator.fromWebID), liveform.Parameter(name='toAddresses', type=liveform.TEXT_INPUT, coercer=self._coerceEmailAddressString)))
def render_postiniForm(self, ctx, data): f = liveform.LiveForm(self.configurePostini, [ liveform.Parameter('usePostiniScore', liveform.CHECKBOX_INPUT, bool, u'Use Postini Score', u'Classify messages based on Postini scores.', default=self.filter.usePostiniScore), liveform.Parameter('postiniThreshhold', liveform.TEXT_INPUT, float, u'Postini Threshold', u'Score below which to consider messages spam.', default=self.filter.postiniThreshhold) ], description='Configure Postini') f.jsClass = u"Quotient.Spam.PostiniSettings" f.setFragmentParent(self) f.docFactory = getLoader('liveform-compact') return ctx.tag[f]
def getWidgetDocument(self): # XXX No support for rendering these yet! f = liveform.LiveForm(self.submit, [liveform.Parameter('argument', None, unicode)]) f.docFactory = loaders.stan( tags.form(render=tags.directive('liveElement')) [tags.select( name="argument")[tags.option(value="apples")["apples"], tags.option(value="oranges")["oranges"]], tags.input(type='submit', render=tags.directive('submitbutton'))]) f.setFragmentParent(self) return f
class ProductFragment(athena.LiveElement): fragmentName = 'product-configuration' live = 'athena' def __init__(self, configger): athena.LiveElement.__init__(self) self.original = configger def head(self): #XXX put this in its own CSS file? return tags.style(type='text/css')[''' input[name=linktext], input[name=subject], textarea[name=blurb] { width: 40em } '''] def getInstallablePowerups(self): for installedOffering in getInstalledOfferings(self.original.store.parent).itervalues(): for p in installedOffering.installablePowerups: yield p def coerceProduct(self, **kw): """ Create a product and return a status string which should be part of a template. @param **kw: Fully qualified Python names for powerup types to associate with the created product. """ self.original.createProduct(filter(None, kw.values())) return u'Created.' def makePowerupCoercer(self, powerup): def powerupCoercer(selectedPowerup): if selectedPowerup: return powerup else: return None return powerupCoercer def makePowerupSelector(self, desc): return liveform.Parameter('selectedPowerup', liveform.CHECKBOX_INPUT, bool, desc) def powerupConfigurationParameter(self, (name, desc, p)): return liveform.Parameter( name, liveform.FORM_INPUT, liveform.LiveForm(self.makePowerupCoercer(p), [self.makePowerupSelector(desc)], name))
def getEditGrabberForm(self, targetID): if self.wt is None: self.wt = self.original.privateApplication grabber = self.wt.fromWebID(targetID) f = liveform.LiveForm( lambda **kwargs: self.editGrabber(grabber, **kwargs), (liveform.Parameter('password1', liveform.PASSWORD_INPUT, unicode, u'New Password'), liveform.Parameter('password2', liveform.PASSWORD_INPUT, unicode, u'Repeat Password'), liveform.Parameter('ssl', liveform.CHECKBOX_INPUT, bool, 'Use SSL', default=grabber.ssl)), description='Edit Grabber') grabber.grab() f.setFragmentParent(self) return unicode(flatten(f), 'utf-8')
def getWidgetDocument(self): f = liveform.LiveForm(self.submit, [ liveform.Parameter('argument', liveform.TEXT_INPUT, unicode, 'A text input field: ', default=u'hello world'), liveform.Parameter( 'group', liveform.FORM_INPUT, liveform.LiveForm(self.paramfilter, [ liveform.Parameter('param1', liveform.TEXT_INPUT, unicode, 'Another input field: ', default=u'goodbye world') ]), 'A form input group: ', ) ]) f.setFragmentParent(self) return f
def __init__(self, parent): self.parent = parent self._commentTypeName = flavorNames[ FLAVOR.commentFlavors[parent.original.flavor]] super(AddCommentFragment, self).__init__( self.addComment, (liveform.Parameter( 'title', liveform.TEXT_INPUT, unicode, 'Title'), liveform.Parameter( 'body', liveform.TEXT_INPUT, unicode, 'Body'), liveform.Parameter( 'tags', liveform.TEXT_INPUT, parseTags))) _docFactorify(self)
def userCreate(self, request, tag): """ Render a form for creating new users. """ userCreator = liveform.LiveForm( self.createUser, [liveform.Parameter( "localpart", liveform.TEXT_INPUT, unicode, "localpart"), liveform.Parameter( "domain", liveform.TEXT_INPUT, unicode, "domain"), liveform.Parameter( "password", liveform.PASSWORD_INPUT, unicode, "password")]) userCreator.setFragmentParent(self) return userCreator
def render_addRule(self, ctx, data): f = liveform.LiveForm( self.addRule, [liveform.Parameter('headerName', None, lambda s: s.strip().lower()), liveform.Parameter('negate', None, lambda s: bool([u"does", u"doesn't"].index(s))), liveform.Parameter('operation', None, _namesToOps.__getitem__), liveform.Parameter('value', None, unicode), liveform.Parameter('shortCircuit', None, bool), liveform.Parameter('caseSensitive', None, bool), liveform.Parameter('tagName', None, unicode)]) f.jsClass = u'Quotient.Filter.RuleWidget' f.docFactory = webtheme.getLoader('add-filtering-rule') f.setFragmentParent(self) return ctx.tag[f]
def render_signupConfigurationForm(self, ctx, data): def makeSignupCoercer(signupPlugin): """ Return a function that converts a selected flag and a set of keyword arguments into either None (if not selected) or a 2-tuple of (signupClass, kwargs). signupClass is a callable which takes the kwargs as keyword arguments and returns an Item (a signup mechanism plugin gizmo). """ def signupCoercer(selectedSignup, **signupConf): """ Receive coerced values from the form post, massage them as described above. """ if selectedSignup: return signupPlugin.itemClass, signupConf return None return signupCoercer def coerceSignup(**kw): return filter(None, kw.values())[0] signupMechanismConfigurations = liveform.LiveForm( # makeSignupCoercer sets it up, we knock it down. (Nones returned # are ignored, there will be exactly one selected). coerceSignup, [ liveform.Parameter( signupMechanism.name, liveform.FORM_INPUT, liveform.LiveForm(makeSignupCoercer(signupMechanism), [ liveform.Parameter('selectedSignup', liveform.RADIO_INPUT, bool, signupMechanism.description) ] + signupMechanism.configuration, signupMechanism.name)) for signupMechanism in self.original.getSignupSystems().itervalues() ], u"Signup Type") def coerceEmailTemplate(**k): return file(sibpath(__file__, 'signup.rfc2822')).read() % k emailTemplateConfiguration = liveform.LiveForm(coerceEmailTemplate, [ liveform.Parameter( 'subject', liveform.TEXT_INPUT, unicode, u'Email Subject', default='Welcome to a Generic Axiom Application!'), liveform.Parameter('blurb', liveform.TEXTAREA_INPUT, unicode, u'Blurb', default=''), liveform.Parameter( 'linktext', liveform.TEXT_INPUT, unicode, u'Link Text', default= "Click here to claim your 'generic axiom application' account") ], description= 'Email Template') emailTemplateConfiguration.docFactory = getLoader('liveform-compact') existing = list(self.original.store.parent.query(_SignupTracker)) if 0 < len(existing): deleteSignupForm = liveform.LiveForm( lambda **kw: self._deleteTrackers(k for (k, v) in kw.itervalues() if v), [ liveform.Parameter('signup-' + str(i), liveform.CHECKBOX_INPUT, lambda wasSelected, tracker=tracker: (tracker, wasSelected), repr(tracker.signupItem)) for (i, tracker) in enumerate(existing) ], description='Delete Existing Signups') deleteSignupForm.setFragmentParent(self) else: deleteSignupForm = '' productPicker = self.makeProductPicker() createSignupForm = liveform.LiveForm(self.createSignup, [ liveform.Parameter( 'signupPrompt', liveform.TEXT_INPUT, unicode, u'Descriptive, user-facing prompt for this signup', default=u'Sign Up'), liveform.Parameter('product', liveform.FORM_INPUT, productPicker, u'Pick some product'), liveform.Parameter('signupTuple', liveform.FORM_INPUT, signupMechanismConfigurations, u'Pick just one dude'), liveform.Parameter('emailTemplate', liveform.FORM_INPUT, emailTemplateConfiguration, u'You know you want to') ], description='Create Signup') createSignupForm.setFragmentParent(self) return [deleteSignupForm, createSignupForm]
prompt: a short unicode string describing this signup mechanism, as distinct from others. For example: "Student Sign Up", or "Faculty Sign Up" @param configuration: a list of LiveForm arguments. """ self.name = name self.description = description self.itemClass = itemClass self.configuration = configuration freeTicketSignupConfiguration = [ liveform.Parameter( 'prefixURL', liveform.TEXT_INPUT, unicode, u'The web location at which users will be able to request tickets.', default=u'signup') ] class FreeTicketSignup(Item, PrefixURLMixin): implements(ISiteRootPlugin) typeName = 'free_signup' schemaVersion = 6 sessioned = True prefixURL = text(allowNone=False) booth = reference()
def textParam(name, label, *a): return liveform.Parameter(name, liveform.TEXT_INPUT, makeRequiredCoercer(name), label, *a)
def __init__(self, composer, recipients=None, subject=u'', messageBody=u'', attachments=(), inline=False, parentMessage=None, parentAction=None): """ @type composer: L{Composer} @param recipients: email addresses of the recipients of this message. defaults to no recipients @type recipients: C{dict} which can contain any combination of the keys C{to}, C{cc} and C{bcc}, where the values are sequences of L{xquotient.mimeutil.EmailAddress} instances @param subject: the subject of this message @type subject: C{unicode} @param messageBody: the body of this message @type messageBody: C{unicode} @param attachments: the attachments of this message @type attachments: sequence of L{xquotient.mimepart.AttachmentPart} instances @param inline: whether the compose widget is being displayed inline, e.g. as a child of another widget @type inline: boolean @param parentMessage: The existing message this message is in response to, if any; otherwise None. @param parentAction: The status that should be set on the parent message, if any, once this message is delivered. Should be a value from L{xquotient.exmess} that ends in C{_STATUS}. C{toAddresses}, C{subject}, C{messageBody} and C{attachments} should be considered as presets - their values can be manipulated via the user interface """ self.composer = composer self.cabinet = self.composer.store.findOrCreate(FileCabinet) self.translator = ixmantissa.IWebTranslator(composer.store) self._savedDraft = None super(ComposeFragment, self).__init__( callable=self._sendOrSave, parameters=[liveform.Parameter(name='fromAddress', type=liveform.TEXT_INPUT, coercer=self.translator.fromWebID), liveform.Parameter(name='toAddresses', type=liveform.TEXT_INPUT, coercer=self._coerceEmailAddressString), liveform.Parameter(name='subject', type=liveform.TEXT_INPUT, coercer=unicode), liveform.Parameter(name='messageBody', type=liveform.TEXTAREA_INPUT, coercer=unicode), liveform.Parameter(name='cc', type=liveform.TEXT_INPUT, coercer=self._coerceEmailAddressString), liveform.Parameter(name='bcc', type=liveform.TEXT_INPUT, coercer=self._coerceEmailAddressString), liveform.Parameter(name='draft', type=liveform.CHECKBOX_INPUT, coercer=bool)]) if recipients is None: recipients = {} self.recipients = recipients self.subject = subject self.messageBody = messageBody self.attachments = attachments self.fileAttachments = [] self.inline = inline self.docFactory = None self.parentMessage = parentMessage self.parentAction = parentAction
def makePowerupSelector(self, desc): return liveform.Parameter('selectedPowerup', liveform.CHECKBOX_INPUT, bool, desc)
def getPreferenceParameters(self): return (liveform.Parameter('foo', liveform.TEXT_INPUT, str), )
def getPreferenceParameters(self): return (liveform.Parameter('preferredWidget', liveform.TEXT_INPUT, unicode, 'Preferred Widget'), )