Example #1
0
    def setThanksFields(self, fields, data):
        omit = filter_fields(self.context, self.schema, data, omit=True)
        new_fields = []
        for fname, field in fields.items():
            if field.mode == HIDDEN_MODE:
                field.mode = DISPLAY_MODE
            new_fields.append(field)
        fields = fields.__class__(*new_fields)
        if omit:
            fields = fields.omit(*omit)

        return fields
Example #2
0
    def get_mail_body(self, unsorted_data, request, context):
        """Returns the mail-body with footer.
        """
        schema = get_schema(context)

        form = DummyFormView(context, request)
        form.schema = schema
        form.prefix = 'form'
        form._update()
        widgets = {name: widget.render() for name, widget in form.w.items()}

        data = filter_fields(self, schema, unsorted_data)

        bodyfield = self.body_pt

        # pass both the bare_fields (fgFields only) and full fields.
        # bare_fields for compatability with older templates,
        # full fields to enable access to htmlValue
        if isinstance(self.body_pre, basestring):
            body_pre = self.body_pre
        else:
            body_pre = self.body_pre.output

        if isinstance(self.body_post, basestring):
            body_post = self.body_post
        else:
            body_post = self.body_post.output

        if isinstance(self.body_footer, basestring):
            body_footer = self.body_footer
        else:
            body_footer = self.body_footer.output

        extra = {
            'data':
            data,
            'fields':
            OrderedDict([(i, j.title) for i, j in getFieldsInOrder(schema)]),
            'widgets':
            widgets,
            'mailer':
            self,
            'body_pre':
            body_pre and lnbr(dollar_replacer(body_pre, data)),
            'body_post':
            body_post and lnbr(dollar_replacer(body_post, data)),
            'body_footer':
            body_footer and lnbr(dollar_replacer(body_footer, data)),
        }
        template = ZopePageTemplate(self.__name__)
        template.write(bodyfield)
        template = template.__of__(context)
        return template.pt_render(extra_context=extra)
Example #3
0
    def get_mail_body(self, unsorted_data, request, context):
        """Returns the mail-body with footer.
        """
        schema = get_schema(context)

        form = DummyFormView(context, request)
        form.schema = schema
        form.prefix = "form"
        form._update()
        widgets = filter_widgets(self, form.w)
        data = filter_fields(self, schema, unsorted_data)

        bodyfield = self.body_pt

        # pass both the bare_fields (fgFields only) and full fields.
        # bare_fields for compatability with older templates,
        # full fields to enable access to htmlValue
        if isinstance(self.body_pre, six.string_types):
            body_pre = self.body_pre
        else:
            body_pre = self.body_pre.output

        if isinstance(self.body_post, six.string_types):
            body_post = self.body_post
        else:
            body_post = self.body_post.output

        if isinstance(self.body_footer, six.string_types):
            body_footer = self.body_footer
        else:
            body_footer = self.body_footer.output

        extra = {
            "data":
            data,
            "fields":
            OrderedDict([(i, j.title) for i, j in getFieldsInOrder(schema)]),
            "widgets":
            widgets,
            "mailer":
            self,
            "body_pre":
            body_pre and lnbr(dollar_replacer(body_pre, data)),
            "body_post":
            body_post and lnbr(dollar_replacer(body_post, data)),
            "body_footer":
            body_footer and lnbr(dollar_replacer(body_footer, data)),
        }
        template = ZopePageTemplate(self.__name__)
        template.write(bodyfield)
        template = template.__of__(context)
        return template.pt_render(extra_context=extra)
Example #4
0
    def setThanksFields(self, fields, data):
        """
        don't show hiddend fields in thank you page
        """
        omit = filter_fields(self.context, self.schema, data, omit=True)
        new_fields = []
        for fname, field in fields.items():
            if field.mode == HIDDEN_MODE:
                continue
            new_fields.append(field)
        fields = fields.__class__(*new_fields)
        if omit:
            fields = fields.omit(*omit)

        return fields
Example #5
0
    def test_selective_fields(self):
        """ Test selective inclusion of fields for mail and thank you page.

        This uses filter_fields, which needs as input:
        - a context (the form or a mailer)
        - a list of widgets
        - (unsorted) data (user input from the request)
        - optional omit=True/False (default False)

        With omit=True, we get a list of field names to omit.
        With omit=False, we get an ordered dict of fields to include.
        """
        # Test the types of answers.
        from collections import OrderedDict as BaseDict
        from collective.easyform.api import OrderedDict

        self.assertIsInstance(
            filter_fields(self.ff1, self.dummy_form.schema, {}), OrderedDict)
        self.assertIsInstance(
            filter_fields(self.ff1, self.dummy_form.schema, {}), BaseDict)
        self.assertIsInstance(
            filter_fields(self.ff1, self.dummy_form.schema, {}), dict)
        self.assertIsInstance(
            filter_fields(self.ff1, self.dummy_form.schema, {}, omit=True),
            list)

        # Empty data
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, {}).keys()),
            [],
        )
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, {},
                               omit=True)),
            [],
        )

        # All data empty
        data = {"replyto": "", "topic": "", "comments": ""}
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, data).keys()),
            ["replyto", "topic", "comments"],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1, self.dummy_form.schema,
                              data).values()),
            ["", "", ""],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1,
                              self.dummy_form.schema,
                              data,
                              omit=True)),
            [],
        )
        self.ff1.includeEmpties = False
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, data).keys()),
            [],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1,
                              self.dummy_form.schema,
                              data,
                              omit=True)),
            ["replyto", "topic", "comments"],
        )

        # All data filled in
        data = {"replyto": "*****@*****.**", "topic": "Test", "comments": "Ni"}
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, data).keys()),
            ["replyto", "topic", "comments"],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1, self.dummy_form.schema,
                              data).values()),
            ["*****@*****.**", "Test", "Ni"],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1,
                              self.dummy_form.schema,
                              data,
                              omit=True)),
            [],
        )

        # Show only specific fields, not active when showAll=True.
        self.ff1.showFields = ("no-such-field", "topic", "comments")
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, data).keys()),
            ["replyto", "topic", "comments"],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1,
                              self.dummy_form.schema,
                              data,
                              omit=True)),
            [],
        )

        # Only show specific fields.
        self.ff1.showAll = False
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, data).keys()),
            ["topic", "comments"],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1,
                              self.dummy_form.schema,
                              data,
                              omit=True)),
            ["replyto"],
        )

        # The order of showFields is kept.
        # Note: currently the order is used on the mail template,
        # but not on the thanks page.
        self.ff1.showFields = ("comments", "no-such-field", "topic")
        self.assertEqual(
            list(filter_fields(self.ff1, self.dummy_form.schema, data).keys()),
            ["comments", "topic"],
        )
        self.assertEqual(
            list(
                filter_fields(self.ff1,
                              self.dummy_form.schema,
                              data,
                              omit=True)),
            ["replyto"],
        )