Metadata-Version: 2.1
Name: django-publishable
Version: 0.1.7
Summary: A simple Django app to add draft/publish capabilities to your models.
Home-page: https://github.com/Ilyes-Hammadi/django-publishable
Author: Ilyes Hammadi
Author-email: hammadiilyesahmed@gmail.com
License: Apache Software License
Platform: UNKNOWN
Classifier: Environment :: Web Environment
Classifier: Framework :: Django
Classifier: Framework :: Django :: 1.11
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.6

# Django-Publishable

Django library that add to your models the draft/publish features.

## Quick start


1. Add "publishable" to your INSTALLED_APPS setting like this::
    ```python

        INSTALLED_APPS = [
            ...
            'publishable',
        ]
    ```
2. Run `python manage.py migrate` to create the publishable models.
3. Try to replicate this with your models:
    ```python
    from django.db import models
    from publishable.models import Publishable, Publisher

    # A Publisher is responsible for triggering 
    # the publish all drafts that he contains
    class User(Publisher):
        pass

    # Overdide the Publishable to implement the logic
    # of broadcast_need_to_published
    class MyPublishable(Publishable):
        class Meta:
            abstract = True

        def broadcast_need_to_published(self):
            """
                This function will return a Draft instance
                then it's up to you select your Publisher
                and add it to it's draft
            """
            draft = super(MyPublishable, self).broadcast_need_to_published()
            chatbot, _ = User.objects.get_or_create(pk=1)
            chatbot.add_draft(draft)

    # After setting up your Publishable
    # then inherit from it into the model that you need to receie
    # draft/publish features
    class Article(MyPublishable):
        title = models.CharField(max_length=255)
        content = models.TextField()

        comments = models.ManyToManyField('Comment', related_name='comments')

        highlighted_comment = models.ForeignKey('Comment', related_name='highlighted_comment', null=True)


    class Comment(MyPublishable):
        content = models.CharField(max_length=255)

    ```
4. By default now all your model will store changes into the draft
    ```python
    # Add changes and publish one model
    >>> a = Article.objects.create()
    >>> a.title = "foo"
    >>> a.publish()
    >>> a.published.title
    foo

    # Let's add changes and publish using a publisher
    >>> a.title = "boo"
    >>> a.save()
    >>> a.published.title
    foo
    >>> user = User.objects.get(pk=1)
    >>> user.publish()

    # You can track the status of the publishing process
    >>> user.publishing_status
    PUBLISHED

    ```

## Using the Context Manager
In order to keep your code clean and avoid replication of code by doing `article.published` all the time, you can use the `PublishedContextManager`. Every operation that you do inside the `with` will target the published version of the model. But be carful do not do any changes to the `published`, you're only supposed to read data, inserting the data should target the `draft`.

```python
>>> from publishable.context_managers import PublishedContextManager
>>> a = Article.objects.create(title="foo")
>>> a.publish()
>>> a.title = "boo"
>>> a.save()
>>> with PublishedContextManager():
        print(a.title)
foo
>>> print(a.title)
boo
```

