[FIXED] Migrating a Django Project using the reversion library to Golang

Issue

We are currently migrating a project from Python (Django) to Golang (Gin). In our application, we use the reversion library. Is there an equivalent in Golang? If not, how can we implement the migration of this functionality in Golang?

@reversion.register()
class DocumentRecommendationMedia(models.Model):
    document = models.ForeignKey("Document.Document", on_delete=models.CASCADE)
    file = models.FileField(upload_to=settings.DOCUMENT_RECOMMENDATION_PATH)
    file_name = models.CharField(max_length=100)

    class Meta:
        db_table = "document_recommendation_media"

@reversion.register(fields=("recommendation", "date", "media_files"))
class DocumentRecommendation(ArchivableModel):
    document = models.ForeignKey("Document.Document", on_delete=models.CASCADE)
    recommendation = models.TextField(null=True, blank=True)
    date = models.DateTimeField(default=timezone.now)
    media_files = models.ManyToManyField(DocumentRecommendationMedia, blank=True)

    class Meta:
        db_table = "document_recommendation"

How to implement this in Golang?

Solution

Migrating a Django project to Golang is a significant shift, as both Django (a Python web framework) and Golang (a statically-typed language) have different paradigms and ecosystems. When it comes to versioning or creating historical records of models, in Django, you might be using a library like django-reversion to manage versioning and history.

In Golang, there isn't a direct equivalent to Django's reversion library, as Golang follows a different set of patterns and practices. However, you can implement similar functionality in Golang by designing your own solution. Here's a basic guideline on how you might approach this:

Define a Struct for Your Model: In Golang, you can define a struct to represent your model. For example:

type Product struct {
    ID      int
    Name    string
    Price   float64
    // other fields
}

Versioning Model: Create another struct to represent a version of your model. This could include fields such as the version number, timestamp, and the actual data.

type ProductVersion struct {
    Version   int
    Timestamp time.Time
    Product   Product
}

Implement Versioning Logic: When you want to version your model, create a new instance of ProductVersion and store it separately. You might use a database table specifically for versioning or another storage mechanism.

func CreateProductVersion(product Product) ProductVersion {
    version := GetNextVersionNumber() // implement your logic to get the next version number
    timestamp := time.Now()

    productVersion := ProductVersion{
        Version:   version,
        Timestamp: timestamp,
        Product:   product,
    }

    // Store the ProductVersion in your database or another storage mechanism

    return productVersion
}

Retrieve Version History: When you want to retrieve the version history of a product, fetch all ProductVersion instances associated with that product.

func GetProductVersionHistory(productID int) []ProductVersion {
    // Implement your logic to retrieve all versions for the given product ID
    // from the database or another storage mechanism
}

Remember that this is a simplified example, and the implementation might vary based on your specific use case and requirements. Additionally, you may need to consider how to handle relationships between models and other aspects of your Django project during migration. It's recommended to carefully plan and test the migration process to ensure a smooth transition.

Answered By - Abdul Ghaffar