python - Django 。记录未正确删除

Question

我遇到了一个问题，希望你能帮助我。

我得到了这些模型:

MODELS = (
('A', 'A'),
('B', 'B'),
)


class person(models.Model):
    nombre = models.CharField(max_length=128)
    model = models.CharField(max_length=128,choices=MODELS, default=True)

    def __str__(self):
        return self.nombre


class person_A(models.Model):
    person = models.ForeignKey(person, on_delete=models.PROTECT, null=True)
    hobbies = models.CharField(max_length=40, default='')

    def __str__(self):
        return self.person.nombre

class person_B(models.Model):
    person = models.ForeignKey(person, on_delete=models.PROTECT, null=True)
    age = models.IntegerField(default=10)

    def __str__(self):
        return self.person.nombre

如你所见，我有 person_A , person_B这将保存在我的数据库中。

这是我的观点:

def get_person(request):
    titulo = 'Person'
    qs_a = person_A.objects.all()
    qs_b = person_B.objects.all()
    qs = chain(qs_b,qs_a)
    form = person_aForm(request.POST or None)
    form2 = personForm(request.POST or None)
    form4 = person_bForm(request.POST or None)
    context = {
        "qs_a": qs_a,
        "qs_b": qs_b,
        "qs": qs,
        "form2": form2,
        "form": form,
        "form4": form4,
        "titulo": titulo,
    }
    form2_valid = form2.is_valid()
    form_valid = form.is_valid()
    form4_valid = form4.is_valid()
    if form2_valid:
        person = form2.save()
        if form_valid:
            person_a = form.save(commit=False)
            person_a.person = person
            person_a.save()
            messages.success(request, 'Se ha guardado satisfactoriamente')
            return redirect("get_person")
        if form4_valid:
            person_b = form4.save(commit=False)
            person_b.person = person
            person_b.save()
            messages.success(request, 'Se ha guardado satisfactoriamente')
            return redirect("get_person")
    return render(request, "person.html", context)

如您所见，我的表单已保存为 person_A或person_B .

这是我的删除功能:

def delete_person(request,id):
    try:
        qs = person_B.objects.all()
        instance = get_object_or_404(qs, id=id)
        instance.delete()
        messages.success(request, 'B')
    except:
        try: 
            qs = person_A.objects.all()
            instance = get_object_or_404(qs, id=id)
            instance.delete()
            messages.success(request, 'A')
        except:
            pass
    return redirect('get_person')

我的网址:

url(r'^delete_person/(?P<id>\d+)/$',views.delete_person, name='delete_person'),

模板:

<table class="table table-hover">
    <thead>
      <tr>
        <th>ID</th>
        <th>Name</th>
        <th>Last Name</th>
        <th>Delete</th>
      </tr>
    </thead>
    <tbody>
    {% for item in qs  %}
      <tr>
        <td>{{ item.id }}</td>
        <td>{{ item.person.model }}</td>
        <td>{{ item.person.nombre }}</td>
        <td><a href="{% url 'delete_person' item.id %}">Delete</a></td>
      </tr>
    {% endfor %}
    </tbody>
</table>

基本上，我有两个不同的模型，每个模型都保存在数据库中并显示在 table 中。为此，我使用了 chain()来自itertools 。我将 A 和 B 加入到一起展示他们 table 。这工作正常，现在这是我的问题:

如果person_A有相同的 id如person_B我想删除person_A ，它将删除 person_B反而。我知道这是因为 chain()但我想知道是否有可能的方法来解决这个问题？

谢谢!

Answer 1

您的问题在于 delete_function() 总是首先尝试删除 person_B 。除非抛出异常，否则 person_A 将永远不会被删除。如果引发异常，您仍将首先删除 person_B，因为它位于 try: block 内，因此尝试删除它总是先于尝试删除 person_A。顺便说一句，按照您现在编写代码的方式，任何异常都会导致尝试删除person_A。我建议使用更具体的异常，否则稍后您可能会遇到真正令人困惑的错误。

至于解决方案，我确信有更聪明的方法，但我现在能想到几个快速而肮脏的解决方案:

1. 定义自定义 filter ，它将检查 person 是什么类型的类并采取相应的操作(例如，为不同的类调用不同的删除方法；将标志传递为 query parameter 并在 delete_person() 中使用它 方法来确定要删除哪个 person_)。

2. 我可能会做什么:不要链接模型实例，而是单独迭代它们并调用适合特定模型的删除方法:

    <table>
    <thead>...</thead>
    <tbody>
      ...
      {% for item in qs_a %}
        <tr>
          <td>... delete_person_A() ...</td>
        </tr>
      {% endfor %}
      {% for item in qs_b %}
        <tr>
          <td>... delete_person_B() ...</td>
        </tr>
      {% endfor %}
    </tbody>
    </table>
   

   如果我没记错的话，chain()会迭代第一个可迭代对象，直到它耗尽，然后才迭代第二个可迭代对象。因此，单独迭代 qs_a 和 qs_b 不会对输出产生巨大差异。虽然这样您将需要编写更多的代码，但它也会更加简单和明确 - 因此，如果需要的话，更容易理解和重构。