django.db.IntegrityError - python examples

Here are the examples of the python api django.db.IntegrityError taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

13 Examples 7

3 View Complete Implementation : models.py
Copyright MIT License
Author : cb109
    def save(self, *args, **kwargs):
        """Equivalent to unique_together('member', 'content_object').

        Generic relations do not support that constraint, so we
        implement it on this level here ourselves.

        """
        if self.content_object.reactions.filter(member=self.member).exists():
            raise IntegrityError(
                "Reaction for object/member combination already exists")
        super(Reaction, self).save(*args, **kwargs)

3 View Complete Implementation : handler.py
Copyright Mozilla Public License 2.0
Author : crutchcorn
def importCSV(csvFile):
    with open(csvFile) as csvfile:
        reader = csv.DictReader(csvfile)
        for row in reader:
            try:
                activation = models.Activation.objects.create(COAID=xNone(row['COA']),
                                                              productKey=row['ProductKey'],
                                                              securityCode=xNone(row['SecurityCode']),
                                                              windowsVer=row['WindowsVer'])
            except IntegrityError:
                raise IntegrityError("The following Activation object had problems being created; COA: "
                                     + row['COA'], "ProductKey: " + row['ProductKey'])
            # If MAC address was given, astign the activation key to the machine
            if row['MAC']:
                findOrCreateMachine(row['MAC'], activation)

3 View Complete Implementation : models.py
Copyright MIT License
Author : ivelum
    def save(self, *args, **kwargs):
        for save_attempt in range(self.max_save_attempts):
            try:
                with transaction.atomic():
                    return super(UIDModel, self).save(*args, **kwargs)
            except IntegrityError as e:
                uid_fields = self.uid_fields()
                if not any(field.attname in str(e) for field in uid_fields):
                    raise
                if save_attempt < self.max_save_attempts - 1:
                    self.populate_uid_fields(
                        force_renew=True, uid_fields=uid_fields
                    )
        raise IntegrityError('Failed to save %s with unique UID fields' % self)

0 View Complete Implementation : workflows.py
Copyright GNU Affero General Public License v3.0
Author : CJWorkbench
def _get_anonymous_workflow_for(workflow: Workflow, request: HttpRequest) -> Workflow:
    """
    If not owner, return a cached duplicate of `workflow`.

    The duplicate will be married to `request.session.session_key`, and its
    `.is_anonymous` will return `True`.
    """
    if not request.session.session_key:
        request.session.create()
    session_key = request.session.session_key

    try:
        return Workflow.objects.get(
            original_workflow_id=workflow.id, anonymous_owner_session_key=session_key
        )
    except Workflow.DoesNotExist:
        try:
            new_workflow = workflow.duplicate_anonymous(session_key)
        except django.db.IntegrityError:
            # Race: the same user just requested a duplicate at the same time,
            # and both decided to duplicate simultaneously. A database
            # constraint means one will get an IntegrityError ... so at this
            # point we can astume our original query will succeed.
            return Workflow.objects.get(
                original_workflow_id=workflow.id,
                anonymous_owner_session_key=session_key,
            )

        async_to_sync(rabbitmq.queue_render)(
            new_workflow.id, new_workflow.last_delta_id
        )
        if workflow.example:
            server.utils.log_user_event_from_request(
                request, "Opened Demo Workflow", {"name": workflow.name}
            )

        return new_workflow

0 View Complete Implementation : serializers.py
Copyright Apache License 2.0
Author : erigones
    def save(self):
        """Update compute node attributes in database"""
        node = self.object

        # NOTE:
        # Changing cpu or disk coefficients can lead to negative numbers in node.cpu/ram_free or dc_node.cpu/ram_free
        try:
            with transaction.atomic():
                node.save(update_resources=self.update_node_resources, clear_cache=self.clear_cache)

                if self.update_node_resources:
                    if node.cpu_free < 0 or node.dcnode_set.filter(cpu_free__lt=0).exists():
                        raise IntegrityError('cpu_check')

                    if node.ram_free < 0 or node.dcnode_set.filter(ram_free__lt=0).exists():
                        raise IntegrityError('ram_check')

        except IntegrityError as exc:
            errors = {}
            exc_error = str(exc)
            # ram or cpu constraint was violated on vms_dcnode (can happen when DcNode strategy is set to RESERVED)
            # OR a an exception was raised above
            if 'ram_check' in exc_error:
                errors['ram_coef'] = self.error_negative_resources
            if 'cpu_check' in exc_error:
                errors['cpu_coef'] = self.error_negative_resources

            if not errors:
                raise exc

            return errors

        if self.update_node_resources:  # cpu_free or ram_free changed
            self.reload()

        return None

0 View Complete Implementation : api_views.py
Copyright Apache License 2.0
Author : erigones
    def put(self, ns):
        """Update node-storage"""
        ser = NodeStorageSerializer(self.request, ns, data=self.data, partial=True)

        if not ser.is_valid():
            return FailureTaskResponse(self.request, ser.errors, obj=ns, dc_bound=False)

        update_storage_resources = ser.update_storage_resources
        is_zones_pool = ser.object.zpool == ser.object.node.zpool

        try:
            with transaction.atomic():
                ser.object.storage.save()
                ser.object.save(update_resources=update_storage_resources, update_dcnode_resources=is_zones_pool)

                if update_storage_resources:
                    if ns.storage.size_free < 0:
                        raise IntegrityError('disk_check')
                    elif is_zones_pool and ns.node.dcnode_set.filter(dc__in=ns.dc.all(), ram_free__lt=0).exists():
                        raise IntegrityError('disk_check')

        except IntegrityError as exc:
            # size constraint was violated on vms_dcnode (can happen when DcNode strategy is set to RESERVED)
            # OR a an exception was raised above
            if 'disk_check' in str(exc):
                errors = {'size_coef': ser.error_negative_resources}
                return FailureTaskResponse(self.request, errors, obj=ns, dc_bound=False)
            else:
                raise exc

        if ser.update_storage_resources:  # size_free changed
            ser.reload()

        return SuccessTaskResponse(self.request, ser.data, obj=ns, detail_dict=ser.detail_dict(), msg=LOG_NS_UPDATE,
                                   dc_bound=False)

0 View Complete Implementation : misc.py
Copyright MIT License
Author : ivelum
def new_uid(max_length, prefix=None,
            chars=string.ascii_letters + string.digits):
    max_generation_attempts = 3
    prefix = prefix or ''
    ln = max_length - len(prefix)
    for i in range(1, max_generation_attempts + 1):
        try:
            # If only digits are used and no prefix specified,
            # ensure that first digit will never be 0
            if not prefix and chars in string.digits and '0' in chars:
                pure_uid = random.choice(str(chars).replace('0', ''))
                pure_uid += ''.join(random.choice(chars) for n in range(ln - 1))
            else:
                pure_uid = ''.join(random.choice(chars) for n in range(ln))

            # UIDs starting from '111' and 'aaa' are system-reserved and
            # should never be generated by application.
            if pure_uid.startswith('111') or pure_uid.lower().startswith('aaa'):
                raise IntegrityError(
                    'Can not generate UIDs starting from "111" or "aaa", '
                    'they are system-reserved.'
                )

            return prefix + pure_uid
        except IntegrityError:
            if i >= max_generation_attempts:
                raise

0 View Complete Implementation : test_regionservice.py
Copyright GNU Affero General Public License v3.0
Author : maas
    @wait_for_reactor
    @inlineCallbacks
    def test_register_raises_CannotRegisterRackController_when_it_cant(self):
        yield self.installFakeRegion()
        patched_create = self.patch(RackController.objects, "create")
        patched_create.side_effect = IntegrityError()
        hostname = factory.make_name("hostname")
        error = yield astert_fails_with(
            call_responder(
                self.make_Region(),
                RegisterRackController,
                {"system_id": None, "hostname": hostname, "interfaces": {}},
            ),
            CannotRegisterRackController,
        )
        self.astertEquals(
            (
                "Failed to register rack controller 'None' with the master. "
                "Connection will be dropped.",
            ),
            error.args,
        )

0 View Complete Implementation : models.py
Copyright The Unlicense
Author : nerosketch
@receiver(models.signals.pre_delete, sender=PeriodicPay)
def periodic_pay_pre_delete(sender, **kwargs):
    raise IntegrityError('All linked abonapp.PeriodicPayForId will be removed, be careful')

0 View Complete Implementation : views.py
Copyright Apache License 2.0
Author : netbox-community
    def post(self, request):

        model = self.model_form._meta.model
        form = self.form(request.POST)
        model_form = self.model_form(request.POST)

        if form.is_valid():

            pattern = form.cleaned_data['pattern']
            new_objs = []

            try:
                with transaction.atomic():

                    # Create objects from the expanded. Abort the transaction on the first validation error.
                    for value in pattern:

                        # Reinstantiate the model form each time to avoid overwriting the same instance. Use a mutable
                        # copy of the POST QueryDict so that we can update the target field value.
                        model_form = self.model_form(request.POST.copy())
                        model_form.data[self.pattern_target] = value

                        # Validate each new object independently.
                        if model_form.is_valid():
                            obj = model_form.save()
                            new_objs.append(obj)
                        else:
                            # Copy any errors on the pattern target field to the pattern form.
                            errors = model_form.errors.as_data()
                            if errors.get(self.pattern_target):
                                form.add_error('pattern', errors[self.pattern_target])
                            # Raise an IntegrityError to break the for loop and abort the transaction.
                            raise IntegrityError()

                    # If we make it to this point, validation has succeeded on all new objects.
                    msg = "Added {} {}".format(len(new_objs), model._meta.verbose_name_plural)
                    messages.success(request, msg)

                    if '_addanother' in request.POST:
                        return redirect(request.path)
                    return redirect(self.get_return_url(request))

            except IntegrityError:
                past

        return render(request, self.template_name, {
            'form': form,
            'model_form': model_form,
            'obj_type': model._meta.verbose_name,
            'return_url': self.get_return_url(request),
        })