Exemple #1
0
    def create(self, validated_data, **kwargs):
        """Create the new workflow."""
        wflow_name = self.context.get('name')
        if not wflow_name:
            wflow_name = self.validated_data.get('name')
            if not wflow_name:
                raise Exception(_('Unexpected empty workflow name.'))

            if models.Workflow.objects.filter(
                    name=wflow_name, user=self.context['user']).exists():
                raise Exception(
                    _('There is a workflow with this name. ' +
                      'Please provide a workflow name in the import page.'))

        # Initial values
        workflow_obj = None
        try:
            workflow_obj = models.Workflow(
                user=self.context['user'],
                name=wflow_name,
                description_text=validated_data['description_text'],
                nrows=0,
                ncols=0,
                attributes=validated_data['attributes'],
                query_builder_ops=validated_data.get('query_builder_ops', {}),
            )
            workflow_obj.save()

            # Create the columns
            column_data = ColumnSerializer(data=validated_data.get(
                'columns', []),
                                           many=True,
                                           context={'workflow': workflow_obj})
            # And save its content
            if column_data.is_valid():
                columns = column_data.save()
            else:
                raise Exception(_('Unable to save column information'))

            # If there is any column with position = 0, recompute (this is to
            # guarantee backward compatibility.
            if any(col.position == 0 for col in columns):
                for idx, col in enumerate(columns):
                    col.position = idx + 1
                    col.save()

            # Load the data frame
            data_frame = validated_data.get('data_frame')
            if data_frame is not None:
                # Store the table in the DB
                pandas.store_table(
                    data_frame,
                    workflow_obj.get_data_frame_table_name(),
                    dtype={
                        col.name: col.data_type
                        for col in workflow_obj.columns.all()
                    },
                )

                # Reconcile now the information in workflow and columns with
                # the one loaded
                workflow_obj.ncols = validated_data['ncols']
                workflow_obj.nrows = validated_data['nrows']

                workflow_obj.save()

            # Create the actions pointing to the workflow
            action_data = ActionSerializer(data=validated_data.get(
                'actions', []),
                                           many=True,
                                           context={
                                               'workflow': workflow_obj,
                                               'columns': columns
                                           })

            if action_data.is_valid():
                action_data.save()
            else:
                raise Exception(_('Unable to save column information'))

            # Create the views pointing to the workflow
            view_data = ViewSerializer(data=validated_data.get('views', []),
                                       many=True,
                                       context={
                                           'workflow': workflow_obj,
                                           'columns': columns
                                       })

            if view_data.is_valid():
                view_data.save()
            else:
                raise Exception(_('Unable to save column information'))
        except Exception:
            # Get rid of the objects created
            if workflow_obj:
                if workflow_obj.id:
                    workflow_obj.delete()
            raise

        return workflow_obj
    def test_serializer_view(self):
        """Test the view serialization."""
        # Try to create a view with a name that already exists.
        try:
            views = ViewSerializer(
                data=[{
                    "columns": [{
                        "name": "email"
                    }, {
                        "name": "one"
                    }, {
                        "name": "registered"
                    }, {
                        "name": "when"
                    }],
                    "name":
                    "simple view",
                    "description_text":
                    "",
                    "formula": {
                        "not": False,
                        "rules": [],
                        "valid": True,
                        "condition": "AND"
                    },
                }],
                many=True,
                context={
                    'workflow': self.workflow,
                    'columns': self.workflow.columns.all()
                },
            )
            self.assertTrue(views.is_valid())
            views.save()
        except IntegrityError as exc:
            self.assertTrue('duplicate key value violates' in str(exc))
        else:
            raise Exception('Incorrect serializer operation.')

        # Try to create a view with a different name
        views = ViewSerializer(
            data=[{
                "columns": [{
                    "name": "email"
                }, {
                    "name": "one"
                }, {
                    "name": "registered"
                }, {
                    "name": "when"
                }],
                "name":
                "simple view 2",
                "description_text":
                "",
                "formula": {
                    "not": False,
                    "rules": [],
                    "valid": True,
                    "condition": "AND"
                },
            }],
            many=True,
            context={
                'workflow': self.workflow,
                'columns': self.workflow.columns.all()
            },
        )
        self.assertTrue(views.is_valid())
        views.save()

        self.assertEqual(self.workflow.views.count(), 2)