django-ctct 0.0.1.dev1__tar.gz → 0.0.1.dev3__tar.gz

{django_ctct-0.0.1.dev1 → django_ctct-0.0.1.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-ctct
-Version: 0.0.1.dev1
+Version: 0.0.1.dev3
 Summary: A Django interface for the Constant Contact API
 License: MIT
 Author: Geoffrey Eisenbarth

{django_ctct-0.0.1.dev1 → django_ctct-0.0.1.dev3}/django_ctct/admin.py

@@ -6,20 +6,23 @@ from requests.exceptions import HTTPError
 from django import forms
 from django.conf import settings
 from django.contrib import admin, messages
+from django.contrib.auth import get_user_model
 from django.db.models import signals
-from django.db.models import Model, QuerySet
+from django.db.models import Model, QuerySet, When, Case, F, FloatField
+from django.db.models.functions import Cast
 from django.forms import ModelForm
 from django.forms.models import BaseInlineFormSet
 from django.http import HttpRequest
+from django.urls import reverse
 from django.utils.html import format_html
 from django.utils.formats import date_format
-from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
 
 from django_ctct.models import (
-  Token, CTCTRemoteModel, ContactList,
-  Contact, CustomField, ContactStreetAddress, ContactPhoneNumber, ContactNote,
-  EmailCampaign, CampaignActivity
+  CTCTRemoteModel, ContactList, CustomField,
+  Contact,
+  ContactCustomField, ContactStreetAddress, ContactPhoneNumber, ContactNote,
+  EmailCampaign, CampaignActivity, CampaignSummary,
 )
 from django_ctct.signals import remote_save, remote_delete
 from django_ctct.vendor import mute_signals
@@ -78,38 +81,6 @@ class ViewModelAdmin(admin.ModelAdmin):
     return False
 
 
-class TokenAdmin(ViewModelAdmin):
-  """Admin functionality for CTCT Tokens."""
-
-  # ListView
-  list_display_links = None
-  list_display = (
-    'scope',
-    'created_at',
-    'expires_at',
-    'copy_access_token',
-    'copy_refresh_token',
-  )
-
-  def copy_access_token(self, obj: Token) -> str:
-    html = format_html(
-      '<button class="button" onclick="{function}">{copy_icon}</button>',
-      function=f"navigator.clipboard.writeText('{obj.access_token}')",
-      copy_icon=mark_safe('&#128203;'),
-    )
-    return html
-  copy_access_token.short_description = _('Access Token')
-
-  def copy_refresh_token(self, obj: Token) -> str:
-    html = format_html(
-      '<button class="button" onclick="{function}">{copy_icon}</button>',
-      function=f"navigator.clipboard.writeText('{obj.refresh_token}')",
-      copy_icon=mark_safe('&#128203;'),
-    )
-    return html
-  copy_refresh_token.short_description = _('Refresh Token')
-
-
 class RemoteModelAdmin(RemoteSyncMixin, admin.ModelAdmin):
   """Facilitate remote saving and deleting."""
 
@@ -212,6 +183,7 @@ class CustomFieldAdmin(RemoteModelAdmin):
     'label',
     'type',
     'created_at',
+    'updated_at',
     'is_synced',
   )
 
@@ -243,13 +215,11 @@ class ContactNoteInline(admin.TabularInline):
   """Inline for adding ContactNotes to a Contact."""
 
   model = ContactNote
-  exclude = ('api_id', )
+  fields = ('content', )
 
-  extra = 1
+  extra = 0
   max_num = Contact.remote.API_MAX_NOTES
 
-  readonly_fields = ('author', 'created_at')
-
   def has_change_permission(
     self,
     request: HttpRequest,
@@ -258,6 +228,14 @@ class ContactNoteInline(admin.TabularInline):
     return False
 
 
+class ContactCustomFieldInline(admin.TabularInline):
+
+  model = ContactCustomField
+  excldue = ('api_id', )
+
+  extra = 0
+
+
 class ContactAdmin(RemoteModelAdmin):
   """Admin functionality for CTCT Contacts."""
 
@@ -317,6 +295,7 @@ class ContactAdmin(RemoteModelAdmin):
   )
   filter_horizontal = ('list_memberships', )
   inlines = (
+    ContactCustomFieldInline,
     ContactPhoneNumberInline,
     ContactStreetAddressInline,
     ContactNoteInline,
@@ -358,6 +337,22 @@ class ContactAdmin(RemoteModelAdmin):
     formset.save_m2m()
 
 
+class ContactNoteAuthorFilter(admin.SimpleListFilter):
+  """Only display Users that have authored a ContactNote."""
+
+  title = _('Author')
+  parameter_name = 'author'
+
+  def lookups(self, request, model_admin):
+    authors = get_user_model().objects.exclude(notes__isnull=True)
+    return [(obj.id, str(obj)) for obj in authors]
+
+  def queryset(self, request, queryset):
+    if self.value():
+      queryset = queryset.filter(author_id=self.value())
+    return queryset
+
+
 class ContactNoteAdmin(RemoteSyncMixin, ViewModelAdmin):
   """Admin functionality for ContactNotes."""
 
@@ -374,17 +369,27 @@ class ContactNoteAdmin(RemoteSyncMixin, ViewModelAdmin):
 
   list_display_links = None
   list_display = (
-    'contact',
+    'contact_link',
     'content',
-    'created_at',
     'author',
+    'created_at',
     'is_synced',
   )
   list_filter = (
     'created_at',
-    'author',
+    ContactNoteAuthorFilter,
   )
 
+  def contact_link(self, obj: ContactNote) -> str:
+    url = reverse(
+      'admin:django_ctct_contact_change',
+      args=[obj.contact.pk],
+    )
+    html = format_html('<a href="{}">{}</a>', url, obj.contact)
+    return html
+  contact_link.short_description = _('Contact')
+  contact_link.admin_order_field = 'contact__email'
+
   def has_delete_permission(self, request: HttpRequest, obj=None):
     """Allow superusers to delete Notes."""
     return request.user.is_superuser
@@ -436,55 +441,23 @@ class EmailCampaignAdmin(RemoteModelAdmin):
   search_fields = ('name', )
   list_display = (
     'name',
-    'updated_at',
     'current_status',
     'scheduled_datetime',
-    'open_rate',
-    'sends',
-    'bounces',
-    'clicks',
-    'optouts',
-    'abuse',
+    'created_at',
+    'updated_at',
     'is_synced',
   )
 
-  def open_rate(self, obj: EmailCampaign) -> str:
-    if obj.current_status == 'DONE':
-      r = (obj.opens / obj.sends) if obj.sends else 0
-      s = f'{r:0.2%}'
-    else:
-      s = '-'
-    return s
-  open_rate.admin_order_field = 'open_rate'
-  open_rate.short_description = _('Open Rate')
-
   # ChangeView
+  fieldsets = (
+    (None, {
+      'fields': (
+        'name', 'current_status', 'scheduled_datetime', 'send_preview'
+      ),
+    }),
+  )
   inlines = (CampaignActivityInline, )
 
-  def get_fieldsets(self, request: HttpRequest, obj=None):
-    if obj and (obj.current_status == 'DONE'):
-      fieldsets = (
-        (None, {
-          'fields': ('name', 'current_status', 'scheduled_datetime'),
-        }),
-        ('ANALYTICS', {
-          'fields': (
-            'sends', 'opens', 'clicks', 'forwards',
-            'optouts', 'abuse', 'bounces', 'not_opened',
-          ),
-        }),
-      )
-    else:
-      fieldsets = (
-        (None, {
-          'fields': (
-            'name', 'current_status', 'scheduled_datetime', 'send_preview'
-          ),
-        }),
-      )
-
-    return fieldsets
-
   def get_readonly_fields(self, request: HttpRequest, obj=None):
     readonly_fields = EmailCampaign.remote.API_READONLY_FIELDS
     if obj and obj.current_status == 'DONE':
@@ -557,10 +530,60 @@ class EmailCampaignAdmin(RemoteModelAdmin):
     self.message_user(request, message)
 
 
+class CampaignSummaryAdmin(ViewModelAdmin):
+  """Admin functionality for CTCT EmailCampaign Summary Report."""
+
+  # ListView
+  search_fields = ('name', )
+  list_display = (
+    'campaign',
+    'open_rate',
+    'sends',
+    'opens',
+    'bounces',
+    'clicks',
+    'optouts',
+    'abuse',
+  )
+
+  def get_queryset(self, request):
+    qs = super().get_queryset(request)
+    qs = qs.annotate(
+      open_rate=Case(
+        When(sends=0, then=0.0),
+        default=Cast(
+          F('opens') * 1.0 / F('sends'),  # Avoid int division
+          output_field=FloatField(),
+        ),
+      ),
+    )
+    return qs
+
+  def open_rate(self, obj: EmailCampaign) -> str:
+    return f'{obj.open_rate:0.0%}'
+  open_rate.admin_order_field = 'open_rate'
+  open_rate.short_description = _('Open Rate')
+
+  # ChangeView
+  fieldsets = (
+    (None, {
+      'fields': (
+        'campaign',
+      ),
+    }),
+    ('ANALYTICS', {
+      'fields': (
+        'sends', 'opens', 'clicks', 'forwards',
+        'optouts', 'abuse', 'bounces', 'not_opened',
+      ),
+    }),
+  )
+
+
 if getattr(settings, 'CTCT_USE_ADMIN', False):
-  admin.site.register(Token, TokenAdmin)
   admin.site.register(ContactList, ContactListAdmin)
   admin.site.register(CustomField, CustomFieldAdmin)
   admin.site.register(Contact, ContactAdmin)
   admin.site.register(ContactNote, ContactNoteAdmin)
   admin.site.register(EmailCampaign, EmailCampaignAdmin)
+  admin.site.register(CampaignSummary, CampaignSummaryAdmin)

{django_ctct-0.0.1.dev1 → django_ctct-0.0.1.dev3}/django_ctct/apps.py

@@ -14,7 +14,6 @@ class CTCTConfig(AppConfig):
     'CTCT_REDIRECT_URI',
     'CTCT_FROM_NAME',
     'CTCT_FROM_EMAIL',
-    'CTCT_ENQUEUE_DEFAULT',
   ]
 
   def ready(self):

django_ctct-0.0.1.dev3/django_ctct/management/commands/import_ctct.py

@@ -0,0 +1,259 @@
+from argparse import ArgumentParser
+from collections import defaultdict
+from typing import Optional, Type
+
+from tqdm import tqdm
+
+import django
+from django.utils.translation import gettext_lazy as _
+from django.core.management.base import BaseCommand
+
+from django_ctct.models import (
+  CTCTModel, ContactList, CustomField,
+  Contact, ContactCustomField,
+  EmailCampaign, CampaignActivity, CampaignSummary,
+)
+
+
+class Command(BaseCommand):
+  """Imports django-ctct model instances from CTCT servers.
+
+  Notes
+  -----
+  CTCT does not provide an endpoint for fetching bulk CampaignActivities.
+  As a result, we must loop through the EmailCampaigns, make a request to get
+  the associated CampaignActivities, and then make a second request to get the
+  details of the CampaignActivity.
+
+  As a result, importing CampaignActivities will be slow, and running it
+  multiple times may result in exceeding CTCT's 10,000 requests per day
+  limit.
+
+  """
+
+  help = 'Imports data from ConstantContact'
+
+  CTCT_MODELS = [
+    ContactList,
+    CustomField,
+    Contact,
+    EmailCampaign,
+    CampaignActivity,
+    CampaignSummary,
+  ]
+
+  def get_id_to_pk(self, model: Type[CTCTModel]) -> dict:
+    """Returns a dictionary to convert CTCT API ids to Django pks."""
+    id_to_pk = {
+      str(api_id): int(pk)
+      for (api_id, pk) in model.objects.values_list('api_id', 'pk')
+    }
+    return id_to_pk
+
+  def upsert(
+    self,
+    model: CTCTModel,
+    objs: list[CTCTModel],
+    update_conflicts: bool = True,
+    unique_fields: list[str] = ['api_id'],
+    update_fields: Optional[list[str]] = None,
+    silent: Optional[bool] = None,
+  ) -> list[CTCTModel]:
+
+    verb = 'Imported' if (update_fields is None) else 'Updated'
+    if silent is None:
+      silent = self.noinput
+
+    # Perform upsert using `bulk_create()`
+    if model._meta.auto_created or (model is ContactCustomField):
+      if not issubclass(model, CTCTModel):
+        # Delete ManyToMany objects
+        model.objects.all().delete()
+      update_conflicts = False
+      unique_fields = update_fields = None
+    elif model is CampaignSummary:
+      update_conflicts = True
+      unique_fields = ['campaign_id']
+      update_fields = model.remote.API_READONLY_FIELDS[1:]
+    elif update_fields is None:
+      update_fields = [
+        f.name
+        for f in model._meta.fields
+        if not f.primary_key and (f.name != 'api_id')
+      ]
+
+    objs_w_pks = model.objects.bulk_create(
+      objs=objs,
+      update_conflicts=update_conflicts,
+      unique_fields=unique_fields,
+      update_fields=update_fields,
+    )
+    if update_conflicts and (django.get_version() < '5.0'):
+      # In older versions, enabling the update_conflicts parameter prevented
+      # setting the primary key on each model instance.
+      if model is not CampaignSummary:
+        # CampaignSummary doesn't have `api_id` field (or related_objs)
+        # so it's okay to skip this part
+        id_to_pk = self.get_id_to_pk(model)
+        [setattr(o, 'pk', id_to_pk[o.api_id]) for o in objs_w_pks]
+
+    # Inform the user
+    if not silent:
+      message = self.style.SUCCESS(
+        f'{verb} {len(objs)} {model.__name__} instances.'
+      )
+      self.stdout.write(message)
+
+    return objs_w_pks
+
+  def set_direct_object_pks(
+    self,
+    model: Type[CTCTModel],
+    instances: list[CTCTModel],
+  ) -> None:
+    """Sets Django pk values for OneToOne and ForeignKeys objects."""
+    for field in model._meta.get_fields():
+      if field.one_to_one or field.many_to_one:
+        # Convert API id to Django pk (hits db)
+        id_to_pk = self.get_id_to_pk(field.remote_field.model)
+        converter = lambda o: id_to_pk[getattr(o, field.attname)]
+
+        [setattr(o, field.attname, converter(o)) for o in instances]
+
+  def set_related_object_pks(
+    self,
+    model: CTCTModel,
+    objs_w_pks: list[CTCTModel],
+    related_fields: list[dict],
+  ) -> None:
+    """Sets Django pk values for ManyToMany and ReverseForeignKey objects."""
+    for obj_w_pk, related_fields in zip(objs_w_pks, related_fields):
+      for related_model, related_objs in related_fields.items():
+        for field in related_model._meta.get_fields():
+          if field.remote_field:
+            if field.name == 'author':
+              # CTCT doesn't store Author info
+              continue
+            if field.many_to_many and (related_objs[0].pk is None):
+              # Can't save ManyToMany until parent object has pk
+              continue
+            elif field.remote_field.model is model:
+              # No need to hit the db, we know the pk is obj_w_pk.pk
+              converter = lambda _: obj_w_pk.pk
+            else:
+              # Convert API id to Django pk (hits db)
+              id_to_pk = self.get_id_to_pk(field.remote_field.model)
+              converter = lambda o: id_to_pk[getattr(o, field.attname)]
+
+            # Set pks on related objects
+            [setattr(o, field.attname, converter(o)) for o in related_objs]
+
+  def import_model(self, model: CTCTModel) -> None:
+    """Imports objects from CTCT into Django's database."""
+
+    if model is CampaignActivity:
+      # CampaignActivities do not have a bulk API endpoint
+      return self.import_campaign_activities()
+
+    model.remote.connect()
+    try:
+      objs, related_fields = zip(*model.remote.all())
+    except ValueError:
+      # No values returned
+      return
+
+    if model is CampaignSummary:
+      # Convert API id to Django pk for the OneToOneField with EmailCampaign
+      self.set_direct_object_pks(model, objs)
+
+    # Upsert models to get Django pks
+    objs_w_pks = self.upsert(model, objs)
+
+    # Convert API id to Django pk for related objects
+    self.set_related_object_pks(model, objs_w_pks, related_fields)
+
+    # Reshape related_fields for efficiency
+    rows, related_fields = related_fields, defaultdict(list)
+    for row in rows:
+      for related_model, related_objs in row.items():
+        related_fields[related_model].extend(related_objs)
+
+    # Upsert related_objs
+    for related_model, related_objs in related_fields.items():
+      self.upsert(related_model, related_objs)
+
+  def import_campaign_activities(self) -> None:
+    """CampaignActivities must be imported one at a time."""
+
+    model = CampaignActivity
+
+    objs_and_related_fields = []
+
+    model.remote.connect()
+    activities = model.objects.filter(role='primary_email')
+    for activity in tqdm(activities, disable=self.noinput):
+      obj, related_fields = model.remote.get(activity.api_id)
+      obj.pk = activity.pk
+      obj.campaign_id = activity.campaign_id
+
+      objs_and_related_fields.append((obj, related_fields))
+
+    # Upsert objects to update fields
+    self.upsert(
+      model=model,
+      objs=[o for (o, _) in objs_and_related_fields],
+      unique_fields=['campaign_id', 'role'],
+      update_fields=['role', 'subject', 'preheader', 'html_content']
+    )
+
+    # Convert API id to Django pk for related objects
+    objs_w_pks, related_fields = zip(*objs_and_related_fields)
+    self.set_related_object_pks(model, objs_w_pks, related_fields)
+
+    # Reshape related_fields for efficiency
+    rows, related_fields = related_fields, defaultdict(list)
+    for row in rows:
+      for related_model, related_objs in row.items():
+        related_fields[related_model].extend(related_objs)
+
+    # Upsert related_objs
+    for related_model, related_objs in related_fields.items():
+      self.upsert(related_model, related_objs)
+
+  def add_arguments(self, parser: ArgumentParser) -> None:
+    """Allow optional keyword arguments."""
+
+    parser.add_argument(
+      '--noinput',
+      action='store_true',
+      default=False,
+      help='Automatic yes to prompts',
+    )
+    parser.add_argument(
+      '--stats_only',
+      action='store_true',
+      default=False,
+      help='Only fetch EmailCampaign statistics',
+    )
+
+  def handle(self, *args, **kwargs):
+    """Primary access point for Django management command."""
+
+    self.noinput = kwargs['noinput']
+    self.stats_only = kwargs['stats_only']
+
+    if self.stats_only:
+      self.CTCT_MODELS = [CampaignSummary]
+
+    for model in self.CTCT_MODELS:
+      if model is CampaignActivity:
+        note = "Note: This will result in 1 API request per EmailCampaign! "
+      else:
+        note = ""
+      question = _(f'Import {model.__name__}? {note}(y/n): ')
+
+      if self.noinput or (input(question).lower()[0] == 'y'):
+        self.import_model(model)
+      else:
+        message = _(f'Skipping {model.__name__}')
+        self.stdout.write(self.style.NOTICE(message))