Synnefo

    def add_quota(self, context={}, clientkey=None, serial=None,

                  sub_quota=(), add_quota=()):

                all_pairs = [(q[0], q[1]) for q in sub_quota + add_quota]

                all_pairs = [(q[0], q[1]) for q in sub_quota + add_quota]

        for removing, source in [(True, sub_quota), (False, add_quota)]:

            for (   entity, resource, key,

                    quantity, capacity,

                    import_limit, export_limit ) in source:

                    try:

                        e = Entity.objects.get(entity=entity, key=key)

                    except Entity.DoesNotExist:

                        append((entity, resource))

                        continue

                    try:

                        h = db_get_holding(entity=entity, resource=resource,

                                           for_update=True)

                        p = h.policy

                    except Holding.DoesNotExist:

                        if removing:

                            append((entity, resource))

                            continue

                        h = Holding(entity=e, resource=resource, flags=0)

                        p = None

                    policy = newname('policy_')

                    newp = Policy(policy=policy)

                    newp.quantity = _add(p.quantity if p else 0, quantity,

                                         invert=removing)

                    newp.capacity = _add(p.capacity if p else 0, capacity,

                                         invert=removing)

                    newp.import_limit = _add(p.import_limit if p else 0,

                                                  import_limit, invert=removing)

                    newp.export_limit = _add(p.export_limit if p else 0,

                                                  export_limit, invert=removing)

                    new_values = [newp.capacity,

                                  newp.import_limit, newp.export_limit]

                    if any(map(_isneg, new_values)):

                        append((entity, resource))

                        continue

                    h.policy = newp

                    # the order is intentionally reversed so that it

                    # would break if we are not within a transaction.

                    # Has helped before.

                    h.save()

                    newp.save()

                    if p is not None and p.holding_set.count() == 0:

                        p.delete()

def _add(x, y, invert=False):

    if invert and y is None:

        return 0

    return x + y if not invert else x - y