ajaxSampleAdd.ajax_submit()

Complexity

Conditions

27

Size

Total Lines

119

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

# -*- coding: utf-8 -*-
    def ajax_submit(self):
        """Submit & create the Samples
        """

        # Get Sample required fields (including extended fields)
        fields = self.get_obj_fields()

        # extract records from request
        records = self.get_records()

        fielderrors = {}
        errors = {"message": "", "fielderrors": {}}

        attachments = {}
        valid_records = []

        # Validate required fields
        for n, record in enumerate(records):

            # Process UID fields first and set their values to the linked field
            uid_fields = filter(lambda f: f.endswith("_uid"), record)
            for field in uid_fields:
                name = field.replace("_uid", "")
                value = record.get(field)
                if "," in value:
                    value = value.split(",")
                record[name] = value

            # Extract file uploads (fields ending with _file)
            # These files will be added later as attachments
            file_fields = filter(lambda f: f.endswith("_file"), record)
            attachments[n] = map(lambda f: record.pop(f), file_fields)

The loop variable record might not be defined here.

            # Required fields and their values
            required_keys = [field.getName() for field in fields if field.required]
            required_values = [record.get(key) for key in required_keys]
            required_fields = dict(zip(required_keys, required_values))

            # Client field is required but hidden in the sample Add form. We
            # remove
            # it therefore from the list of required fields to let empty
            # columns pass the required check below.
            if record.get("Client", False):
                required_fields.pop('Client', None)

            # None of the required fields are filled, skip this record
            if not any(required_fields.values()):
                continue

            # Missing required fields
            missing = [f for f in required_fields if not record.get(f, None)]

            # If there are required fields missing, flag an error
            for field in missing:
                fieldname = "{}-{}".format(field, n)
                msg = _("Field '{}' is required".format(field))
                fielderrors[fieldname] = msg

            # Process valid record
            valid_record = dict()
            for fieldname, fieldvalue in record.iteritems():
                # clean empty
                if fieldvalue in ['', None]:
                    continue
                valid_record[fieldname] = fieldvalue

            # append the valid record to the list of valid records
            valid_records.append(valid_record)

        # return immediately with an error response if some field checks failed
        if fielderrors:
            errors["fielderrors"] = fielderrors
            return {'errors': errors}

        # Process Form
        samples = []
        for n, record in enumerate(valid_records):
            client_uid = record.get("Client")
            client = self.get_object_by_uid(client_uid)

            if not client:
                raise RuntimeError("No client found")

            # Create the Sample
            try:
                sample = create_sample(client, self.request, record)
            except (KeyError, RuntimeError) as e:
                errors["message"] = e.message
                return {"errors": errors}
            samples.append(sample.Title())

        level = "info"
        if len(samples) == 0:
            message = _('No Sample could be created.')
            level = "error"
        elif len(samples) > 1:
            message = _('Samples ${samples} were successfully created.',
                        mapping={'Samples': safe_unicode(', '.join(samples))})
        else:
            message = _('Analysis request ${Sample} was successfully created.',
                        mapping={'Sample': safe_unicode(samples[0])})

        # Display a portal message
        self.context.plone_utils.addPortalMessage(message, level)

        bika_setup = api.get_bika_setup()
        auto_print = bika_setup.getAutoPrintStickers()

        # https://github.com/bikalabs/bika.lims/pull/2153
        new_samples = [a for a in samples if a[-1] == '1']

        if 'register' in auto_print and new_samples:
            return {
                'success': message,
                'stickers': new_samples,
                'stickertemplate': self.context.bika_setup.getAutoStickerTemplate()
            }
        else:
            return {'success': message}