from django.db import models
from django.utils.translation import ugettext_lazy as _
from import Contact
import datetime
import logging
log = logging.getLogger('newsletter.models')
_NOTSET = object()
class NullContact(object):
    """Simple object emulating a Contact, so that we can add users who aren't Satchmo Contacts.
    Note, this is *not* a Django object, and is not saved to the DB, only to the subscription lists.
    def __init__(self, full_name, email):
        if not full_name:
            full_name = email.split('@')[0]
        self.full_name = full_name = email
def get_contact_or_fake(full_name, email):
    """Get a `Contact` by email or if it doesn't exist, then a `NullContact`"""
        contact = Contact.objects.get(email=email)
    except Contact.DoesNotExist:
        contact = NullContact(full_name, email)
    return contact
class Subscription(models.Model):
    """A newsletter subscription."""
    subscribed = models.BooleanField(_('Subscribed'), default=True)
    email = models.EmailField(_('Email'), max_length=75)
    create_date = models.DateField(_("Creation Date"))
    update_date = models.DateField(_("Update Date"))
    def email_is_subscribed(cls, email):
            sub = cls.objects.get(email=email)
            return sub.subscribed
        except cls.DoesNotExist:
            return False
    email_is_subscribed = classmethod(email_is_subscribed)
    def __unicode__(self):
        if self.subscribed:
        return u"[%s] %s" % (flag,
    def __repr__(self):
        return "<Subscription: %s>" % str(self)
    def attribute_value(self, name, value=_NOTSET):
        """Get a value from an attribute."""
            att = self.attributes.get(name=name)
            value = att.value
        except SubscriptionAttribute.DoesNotExist:
            if value != _NOTSET:
        return value
    def save(self, **kwargs):
        if not
            self.create_date =
        self.update_date =
        super(Subscription, self).save(**kwargs)
    def update_attribute(self, name, value):
        """Update or create a `SubscriptionAttribute` object with the passed `name` and `value`."""
        value = str(value)
            att = self.attributes.get(name=name)
            att.value = value
        except SubscriptionAttribute.DoesNotExist:
            att = SubscriptionAttribute(subscription=self, name=name, value=value)

        return att
    def update_attributes(self, attributes):
        """Update `SubscriptionAttribute` objects from a dictionary of name val mappings."""
        return [self.update_attribute(name, value) for name, value in attributes.items()]
class SubscriptionAttribute(models.Model):
    Allows arbitrary name/value pairs (as strings) to be attached to a subscription.
    subscription = models.ForeignKey(Subscription, related_name="attributes")
    name = models.SlugField(_("Attribute Name"), max_length=100, )
    value = models.CharField(_("Value"), max_length=255)
    class Meta:
        verbose_name = _("Subscription Attribute")
        verbose_name_plural = _("Subscription Attributes")
import config
import listeners