Django: Preserving user data after account deletion in e-commerce orders

Ecom
1

I’m working on an e-commerce site using Django. I have two models: Customer and Purchase. I want to keep customer info for each purchase even if they delete their account. But I’m not sure how to do this without duplicating data.

Here’s what I’ve tried:

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

class Purchase(models.Model):
    buyer_email = models.EmailField()
    buyer_name = models.CharField(max_length=100)
    buyer = models.ForeignKey(get_user_model(), null=True, on_delete=models.SET_NULL)

    def before_save(self):
        if self.buyer:
            self.buyer_email = self.buyer.email
            self.buyer_name = f'{self.buyer.first_name} {self.buyer.last_name}'

    def save(self, *args, **kwargs):
        self.before_save()
        super().save(*args, **kwargs)

This works, but it feels like I’m repeating data. Is there a better way to handle this? Or is some duplication unavoidable in this case? Any tips would be great!

2

I’ve faced a similar challenge in my e-commerce projects. While your current approach works, there’s a more elegant solution: soft deletion. Instead of duplicating data, you can add an ‘is_active’ boolean field to your User model. When a user ‘deletes’ their account, you simply set this to False.

Here’s how you might modify your models:

class CustomUser(AbstractUser):
    is_active = models.BooleanField(default=True)

class Purchase(models.Model):
    buyer = models.ForeignKey(CustomUser, on_delete=models.SET_NULL, null=True)

    def get_buyer_info(self):
        if self.buyer:
            return f'{self.buyer.email} ({self.buyer.get_full_name()})'
        return 'Deleted User'

This way, you maintain data integrity without duplication. It also allows for account reactivation if needed. Remember to update your views and admin panel to filter by ‘is_active’ when displaying users.

3

Hey there, fellow Django dev! I’ve been pondering your question, and it’s got me thinking about some interesting angles. Have you considered using a soft delete approach? It’s pretty nifty!

Instead of actually deleting the user account, you could just mark it as inactive. Something like this:

class User(AbstractUser):
    is_active = models.BooleanField(default=True)

    def soft_delete(self):
        self.is_active = False
        self.save()

Then in your Purchase model, you could do:

class Purchase(models.Model):
    buyer = models.ForeignKey(User, on_delete=models.SET_NULL, null=True)

    def get_buyer_info(self):
        if self.buyer:
            return f'{self.buyer.email} ({self.buyer.get_full_name()})'
        return 'Account Deactivated'

This way, you’re not duplicating data, but you’re still keeping all the info you need. Plus, if a user ever wants to reactivate their account, it’s super easy!

What do you think about this approach? Have you tried anything like this before? I’m curious to hear your thoughts!

4

hey isaac, have u thought about using a seperate table for purchase-related user info? it could look like this:

class PurchaseUserInfo(models.Model):
    email = models.EmailField()
    name = models.CharField(max_length=100)

class Purchase(models.Model):
    user_info = models.ForeignKey(PurchaseUserInfo, on_delete=models.PROTECT)
    # other fields

this way, u keep user data even if they delete their account. what do u think?