Django: How Can You Detach a User While Keeping Crucial Order Information in E-commerce?

Ecom
1

How can a Django e-commerce app remove a user account yet retain essential order details?

from django.db import models
from django.contrib.auth import get_user_model as fetch_user

class Purchase(models.Model):
    email_address = models.EmailField()
    first_name = models.CharField(max_length=50)
    surname = models.CharField(max_length=50)
    owner = models.ForeignKey(fetch_user(), null=True, on_delete=models.SET_NULL)

    def verify(self):
        if not self.first_name:
            self.first_name = self.owner.first_name
        if not self.surname:
            self.surname = self.owner.last_name
        if not self.email_address:
            self.email_address = self.owner.email

    def commit(self, *args, **kwargs):
        self.verify()
        return super().save(*args, **kwargs)
2

In my experience, the most reliable method is to ensure that user details required for order completion are stored in the order model before account deletion. I achieved this by overriding the user deletion process and using Django signals where appropriate, so that when a user initiates account removal, a dedicated function automatically replicates the necessary fields into the order record. This approach guarantees that order integrity remains intact without a persistent link to the user. It has proven more robust than attempting to maintain a foreign key after deletion since all vital data is securely duplicated.

3

hey guys, i solved it by copying user info to the order recrod pre-deletion via a custom signal. it’s a bit hacky but it avoids losing critical order data. any other better ideas?

4

Hey everyone, thanks for all the cool insights so far! I was mulling over this and though signals and detaching the foreign key are great, what about exploring a soft deletion approach for user accounts instead? Instead of wiping out the user record entirely, you could mark the account as inactive or archived. This way, you maintain the link between orders and users without actually keeping an active user account around. It might also simplify auditing and troubleshooting later on.

Alternatively, if your business rules insist on permanent deletion of user data, then having an archiving system either in the same table or even a separate table could be useful. This ensures that the original order retains the necessary info without keeping a live user object. Has anyone tried setting up such an archival system in Django? I’d love to hear if the extra complexity on the database side pays off in terms of maintaining integrity and performance over time.

What do you all think? Could soft deletion or a dedicated archive model be a more robust option, or do you think the signal-based approach is the way to go? Keen to know your experiences and any pitfalls you might have encountered with either method!

5

Hey everyone, interesting topic indeed! I was pondering on this and one approach that caught my attention was decoupling the transactional data from the user account completely. What if, before deleting the user, we have a process where the purchase record ‘seizes’ all necessary details from the user and then resets or nullifies the foreign key? This way, the order details remain intact, and we effectively lose the link with the user profile. I’m curious if anyone here has experimented with using Django signals to automatically clone the relevant user attributes into the order entry right before account deletion. Has anyone tried a similar method or maybe found some caveats when doing it this way? Let’s discuss!