Models and signup & login views for consumer_user_poc

corehq/apps/consumer_user/__init__.py

@@ -0,0 +1,12 @@
+from django.apps import AppConfig
+
+
+class ConsumerUserAppConfig(AppConfig):
+    name = 'corehq.apps.consumer_user'
+
+    def ready(self):
+        from corehq.apps.consumer_user.signals import connect_signals
+        connect_signals()
+
+
+default_app_config = 'corehq.apps.consumer_user.ConsumerUserAppConfig'

corehq/apps/consumer_user/admin.py

@@ -0,0 +1,5 @@
+from django.contrib import admin
+
+from corehq.apps.consumer_user.models import ConsumerUser
+
+admin.site.register(ConsumerUser)

corehq/apps/consumer_user/const.py

@@ -0,0 +1,5 @@
+CONSUMER_INVITATION_CASE_TYPE = 'commcare-consumeruserinvitation'
+
+CONSUMER_INVITATION_STATUS = 'status'
+CONSUMER_INVITATION_SENT = 'sent'
+CONSUMER_INVITATION_ACCEPTED = 'accepted'

corehq/apps/consumer_user/decorators.py

@@ -0,0 +1,19 @@
+from functools import wraps
+
+from django.contrib.auth.views import redirect_to_login
+from django.urls import reverse
+
+from corehq.apps.consumer_user.models import ConsumerUser
+
+
+def consumer_user_login_required(view_func):
+    @wraps(view_func)
+    def _inner(request, *args, **kwargs):
+        user = request.user
+        if not (user.is_authenticated and user.is_active and ConsumerUser.objects.get_or_none(user=user)):
+            url = reverse('consumer_user:consumer_user_login')
+            return redirect_to_login(request.get_full_path(), url)
+
+        # User login validated and verified corresponding ConsumerUser exists- it's safe to call the view function
+        return view_func(request, *args, **kwargs)
+    return _inner

corehq/apps/consumer_user/forms/change_contact_details_form.py

@@ -0,0 +1,16 @@
+from django.contrib.auth.models import User
+from django.forms import ModelForm
+
+
+class ChangeContactDetailsForm(ModelForm):
+    class Meta:
+        model = User
+        fields = ['first_name', 'last_name']
+
+    def save(self, commit=True):
+        user = super(ChangeContactDetailsForm, self).save(commit=False)
+        user.first_name = self.cleaned_data["first_name"]
+        user.last_name = self.cleaned_data["last_name"]
+        if commit:
+            user.save()
+        return user

corehq/apps/consumer_user/forms/consumer_user_authentication_form.py

@@ -0,0 +1,48 @@
+from django import forms
+from django.contrib.auth.forms import AuthenticationForm
+from django.core.exceptions import ValidationError
+from django.utils.translation import ugettext_lazy as _
+
+from corehq.apps.consumer_user.const import (
+    CONSUMER_INVITATION_ACCEPTED,
+    CONSUMER_INVITATION_STATUS,
+)
+from corehq.apps.consumer_user.models import (
+    ConsumerUser,
+    ConsumerUserCaseRelationship,
+)
+from corehq.apps.domain.forms import NoAutocompleteMixin
+from corehq.apps.hqcase.utils import update_case
+
+
+class ConsumerUserAuthenticationForm(NoAutocompleteMixin, AuthenticationForm):
+    username = forms.EmailField(label=_("Email Address"),
+                                widget=forms.TextInput(attrs={'class': 'form-control'}),
+                                required=True)
+    password = forms.CharField(label=_("Password"),
+                               widget=forms.PasswordInput(attrs={'class': 'form-control'}),
+                               required=True)
+
+    def __init__(self, *args, **kwargs):
+        self.invitation = kwargs.pop('invitation', None)
+        super().__init__(*args, **kwargs)
+
+    def clean(self):
+        username = self.cleaned_data.get('username')
+        if username is None:
+            raise ValidationError(_('Please enter a valid email address.'))
+
+        password = self.cleaned_data.get('password')
+        if not password:
+            raise ValidationError(_("Please enter a password."))
+        cleaned_data = super(ConsumerUserAuthenticationForm, self).clean()
+        consumer_user = ConsumerUser.objects.get_or_create(user=self.user_cache)
+        if self.invitation and not self.invitation.accepted:
+            self.invitation.accept()
+            ConsumerUserCaseRelationship.objects.create(case_id=self.invitation.demographic_case_id,
+                                                        domain=self.invitation.domain,
+                                                        consumer_user=consumer_user[0])
+            update_case(self.invitation.domain,
+                        self.invitation.case_id,
+                        {CONSUMER_INVITATION_STATUS: CONSUMER_INVITATION_ACCEPTED})
+        return cleaned_data

corehq/apps/consumer_user/forms/consumer_user_signup_form.py

@@ -0,0 +1,57 @@
+from django.contrib.auth.models import User
+from django.core.exceptions import ValidationError
+from django.forms import CharField, ModelForm, PasswordInput
+from django.utils.translation import ugettext_lazy as _
+
+from corehq.apps.consumer_user.const import (
+    CONSUMER_INVITATION_ACCEPTED,
+    CONSUMER_INVITATION_STATUS,
+)
+from corehq.apps.consumer_user.models import (
+    ConsumerUser,
+    ConsumerUserCaseRelationship,
+)
+from corehq.apps.hqcase.utils import update_case
+
+
+class ConsumerUserSignUpForm(ModelForm):
+
+    email = CharField(required=True)
+
+    def __init__(self, *args, **kwargs):
+        self.invitation = kwargs.pop('invitation', None)
+        super().__init__(*args, **kwargs)
+        self.fields['email'].label = 'Email Address'
+        for key in self.fields:
+            self.fields[key].required = True
+
+    class Meta:
+        model = User
+        fields = ['first_name', 'last_name', 'email', 'password']
+        widgets = {
+            'password': PasswordInput(),
+        }
+
+    def clean_email(self):
+        email = self.cleaned_data['email']
+        if User.objects.filter(username=email).exists():
+            raise ValidationError(_(u'Username "%s" is already in use.' % email))
+        return email
+
+    def save(self, commit=True):
+        user = super(ConsumerUserSignUpForm, self).save(commit=False)
+        user.set_password(self.cleaned_data["password"])
+        user.username = self.cleaned_data['email']
+        if commit:
+            user.save()
+            consumer_user = ConsumerUser.objects.create(user=user)
+            if self.invitation:
+                self.invitation.accepted = True
+                self.invitation.save()
+                ConsumerUserCaseRelationship.objects.create(case_id=self.invitation.demographic_case_id,
+                                                            domain=self.invitation.domain,
+                                                            consumer_user=consumer_user)
+                update_case(self.invitation.domain,
+                            self.invitation.case_id,
+                            {CONSUMER_INVITATION_STATUS: CONSUMER_INVITATION_ACCEPTED})
+        return user

corehq/apps/consumer_user/migrations/0001_initial.py

@@ -0,0 +1,52 @@
+# Generated by Django 2.2.16 on 2021-03-05 10:32
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ConsumerUser',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE,
+                                              to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='ConsumerUserInvitation',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('email', models.EmailField(max_length=254)),
+                ('case_id', models.CharField(max_length=255)),
+                ('demographic_case_id', models.CharField(max_length=255)),
+                ('domain', models.CharField(max_length=255)),
+                ('accepted', models.BooleanField(default=False)),
+                ('invited_by', models.CharField(max_length=255)),
+                ('invited_on', models.DateTimeField(auto_now=True)),
+                ('active', models.BooleanField(default=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='ConsumerUserCaseRelationship',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('case_id', models.CharField(max_length=255)),
+                ('domain', models.CharField(max_length=255)),
+                ('consumer_user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
+                                                    to='consumer_user.ConsumerUser')),
+            ],
+            options={
+                'unique_together': {('case_id', 'domain')},
+            },
+        ),
+    ]

corehq/apps/consumer_user/models.py

@@ -0,0 +1,57 @@
+from django.contrib.auth.models import User
+from django.db import models
+
+
+class GetOrNoneManager(models.Manager):
+    """
+    Adds get_or_none method to objects
+    """
+
+    def get_or_none(self, **kwargs):
+        try:
+            return self.get(**kwargs)
+        except self.model.DoesNotExist:
+            return None
+
+
+class ConsumerUser(models.Model):
+    user = models.OneToOneField(User, on_delete=models.CASCADE)
+    objects = GetOrNoneManager()
+
+
+class ConsumerUserCaseRelationship(models.Model):
+    consumer_user = models.ForeignKey(ConsumerUser, on_delete=models.CASCADE)
+    case_id = models.CharField(max_length=255)
+    domain = models.CharField(max_length=255)
+
+    class Meta:
+        unique_together = ('case_id', 'domain',)
+
+
+class ConsumerUserInvitation(models.Model):
+    email = models.EmailField()
+    case_id = models.CharField(max_length=255)
+    demographic_case_id = models.CharField(max_length=255)
+    domain = models.CharField(max_length=255)
+    accepted = models.BooleanField(default=False)
+    invited_by = models.CharField(max_length=255)
+    invited_on = models.DateTimeField(auto_now=True)
+    active = models.BooleanField(default=True)
+
+    def make_inactive(self):
+        self.active = False
+        self.save(update_fields=['active'])
+
+    def accept(self):
+        self.accepted = True
+        self.save(update_fields=['accepted'])
+
+    @classmethod
+    def create_invitation(cls, case_id, domain, demographic_case_id, opened_by, email):
+        instance = cls(case_id=case_id,
+                       domain=domain,
+                       demographic_case_id=demographic_case_id,
+                       invited_by=opened_by,
+                       email=email)
+        instance.save()
+        return instance

corehq/apps/consumer_user/signals.py

@@ -0,0 +1,55 @@
+from casexml.apps.case.const import CASE_INDEX_EXTENSION
+
+from corehq.apps.consumer_user.models import (
+    ConsumerUserCaseRelationship,
+    ConsumerUserInvitation,
+)
+from corehq.form_processor.models import CommCareCaseSQL
+from corehq.form_processor.signals import sql_case_post_save
+
+from .const import (
+    CONSUMER_INVITATION_ACCEPTED,
+    CONSUMER_INVITATION_CASE_TYPE,
+    CONSUMER_INVITATION_SENT,
+    CONSUMER_INVITATION_STATUS,
+)
+from .tasks import create_new_invitation
+
+
+def send_email_case_changed_receiver(sender, case, **kwargs):
+    if case.type != CONSUMER_INVITATION_CASE_TYPE:
+        return
+    email = case.get_case_property('email')
+    status = case.get_case_property(CONSUMER_INVITATION_STATUS)
+
+    host_indices = [index for index in case.indices if index.relationship == CASE_INDEX_EXTENSION]
+    try:
+        demographic_case_id = host_indices[0].referenced_id
+    except IndexError:
+        return
+
+    invitation = ConsumerUserInvitation.objects.filter(case_id=case.case_id,
+                                                       domain=case.domain,
+                                                       demographic_case_id=demographic_case_id,
+                                                       active=True).last()
+    is_status_sent_or_accepted = status == CONSUMER_INVITATION_SENT or status == CONSUMER_INVITATION_ACCEPTED
+    if case.closed:
+        if invitation:
+            invitation.make_inactive()
+        return
+    elif invitation and email == invitation.email and is_status_sent_or_accepted:
+        return
+    elif invitation:
+        invitation.make_inactive()
+        if ConsumerUserCaseRelationship.objects.filter(case_id=demographic_case_id,
+                                                       domain=case.domain).exists():
+            return
+    create_new_invitation.delay(case.case_id, case.domain, demographic_case_id, case.opened_by, email)
+
+
+def connect_signals():
+    sql_case_post_save.connect(
+        send_email_case_changed_receiver,
+        CommCareCaseSQL,
+        dispatch_uid='send_email_case_changed_receiver'
+    )

corehq/apps/consumer_user/tasks.py

@@ -0,0 +1,39 @@
+from django.conf import settings
+from django.core.signing import TimestampSigner
+from django.template.loader import render_to_string
+from django.urls import reverse
+from django.utils.encoding import force_bytes
+from django.utils.http import urlsafe_base64_encode
+from django.utils.translation import ugettext_lazy as _
+
+from celery.task import task
+
+from dimagi.utils.web import get_url_base
+
+from corehq.apps.consumer_user.models import ConsumerUserInvitation
+from corehq.apps.hqcase.utils import update_case
+from corehq.apps.hqwebapp.tasks import send_html_email_async
+
+from .const import CONSUMER_INVITATION_SENT, CONSUMER_INVITATION_STATUS
+
+
+@task
+def create_new_invitation(case_id, domain, demographic_case_id, opened_by, email):
+    invitation = ConsumerUserInvitation.create_invitation(case_id, domain, demographic_case_id, opened_by, email)
+    url = '%s%s' % (get_url_base(),
+                    reverse('consumer_user:consumer_user_register',
+                            kwargs={
+                                'invitation': TimestampSigner().sign(urlsafe_base64_encode(
+                                    force_bytes(invitation.pk)
+                                ))
+                            }))
+    email_context = {
+        'link': url,
+    }
+    send_html_email_async.delay(
+        _('Beneficiary Registration'),
+        email,
+        render_to_string('email/registration_email.html', email_context),
+        text_content=render_to_string('email/registration_email.txt', email_context)
+    )
+    update_case(domain, case_id, {CONSUMER_INVITATION_STATUS: CONSUMER_INVITATION_SENT})