working on foreignkey django examples

mattmakai · mattmakai · commit f4e727aad683 · 2019-12-11T06:01:45.000-05:00
diff --git a/content/pages/examples/django/django-db-models-foreignkey.markdown b/content/pages/examples/django/django-db-models-foreignkey.markdown
@@ -293,7 +293,7 @@ from django.contrib.auth import authenticate
 from django.contrib.sites.models import Site
 from django.contrib.sites.shortcuts import get_current_site
 from django.core.exceptions import PermissionDenied
-from django.db import models
+~~from django.db import models
 from django.utils.crypto import get_random_string
 
 import allauth.app_settings
@@ -312,60 +312,13 @@ from .adapter import get_adapter
 from .fields import JSONField
 
 
-class SocialAppManager(models.Manager):
-    def get_current(self, provider, request=None):
-        cache = {}
-        if request:
-            cache = getattr(request, '_socialapp_cache', {})
-            request._socialapp_cache = cache
-        app = cache.get(provider)
-        if not app:
-            site = get_current_site(request)
-            app = self.get(
-                sites__id=site.id,
-                provider=provider)
-            cache[provider] = app
-        return app
-
-
-@python_2_unicode_compatible
-class SocialApp(models.Model):
-    objects = SocialAppManager()
-
-    provider = models.CharField(verbose_name=_('provider'),
-                                max_length=30,
-                                choices=providers.registry.as_choices())
-    name = models.CharField(verbose_name=_('name'),
-                            max_length=40)
-    client_id = models.CharField(verbose_name=_('client id'),
-                                 max_length=191,
-                                 help_text=_('App ID, or consumer key'))
-    secret = models.CharField(verbose_name=_('secret key'),
-                              max_length=191,
-                              help_text=_('API secret, client secret, or'
-                              ' consumer secret'))
-    key = models.CharField(verbose_name=_('key'),
-                           max_length=191,
-                           blank=True,
-                           help_text=_('Key'))
-    # Most apps can be used across multiple domains, therefore we use
-    # a ManyToManyField. Note that Facebook requires an app per domain
-    # (unless the domains share a common base name).
-    # blank=True allows for disabling apps without removing them
-    sites = models.ManyToManyField(Site, blank=True)
-
-    class Meta:
-        verbose_name = _('social application')
-        verbose_name_plural = _('social applications')
-
-    def __str__(self):
-        return self.name
+## ... source file abbreviated to get to ForeignKey examples ...
 
 
 @python_2_unicode_compatible
 class SocialAccount(models.Model):
-    user = models.ForeignKey(allauth.app_settings.USER_MODEL,
-                             on_delete=models.CASCADE)
+~~    user = models.ForeignKey(allauth.app_settings.USER_MODEL,
+~~                             on_delete=models.CASCADE)
     provider = models.CharField(verbose_name=_('provider'),
                                 max_length=30,
                                 choices=providers.registry.as_choices())
@@ -401,8 +354,8 @@ class SocialAccount(models.Model):
     def authenticate(self):
         return authenticate(account=self)
 
-    def __str__(self):
-        return force_str(self.user)
+~~    def __str__(self):
+~~        return force_str(self.user)
 
     def get_profile_url(self):
         return self.get_provider_account().get_profile_url()
@@ -419,8 +372,8 @@ class SocialAccount(models.Model):
 
 @python_2_unicode_compatible
 class SocialToken(models.Model):
-    app = models.ForeignKey(SocialApp, on_delete=models.CASCADE)
-    account = models.ForeignKey(SocialAccount, on_delete=models.CASCADE)
+~~    app = models.ForeignKey(SocialApp, on_delete=models.CASCADE)
+~~    account = models.ForeignKey(SocialAccount, on_delete=models.CASCADE)
     token = models.TextField(
         verbose_name=_('token'),
         help_text=_(
@@ -442,174 +395,7 @@ class SocialToken(models.Model):
         return self.token
 
 
-class SocialLogin(object):
-    """
-    Represents a social user that is in the process of being logged
-    in. This consists of the following information:
-
-    `account` (`SocialAccount` instance): The social account being
-    logged in. Providers are not responsible for checking whether or
-    not an account already exists or not. Therefore, a provider
-    typically creates a new (unsaved) `SocialAccount` instance. The
-    `User` instance pointed to by the account (`account.user`) may be
-    prefilled by the provider for use as a starting point later on
-    during the signup process.
-
-    `token` (`SocialToken` instance): An optional access token token
-    that results from performing a successful authentication
-    handshake.
-
-    `state` (`dict`): The state to be preserved during the
-    authentication handshake. Note that this state may end up in the
-    url -- do not put any secrets in here. It currently only contains
-    the url to redirect to after login.
-
-    `email_addresses` (list of `EmailAddress`): Optional list of
-    e-mail addresses retrieved from the provider.
-    """
-
-    def __init__(self, user=None, account=None, token=None,
-                 email_addresses=[]):
-        if token:
-            assert token.account is None or token.account == account
-        self.token = token
-        self.user = user
-        self.account = account
-        self.email_addresses = email_addresses
-        self.state = {}
-
-    def connect(self, request, user):
-        self.user = user
-        self.save(request, connect=True)
-
-    def serialize(self):
-        serialize_instance = get_adapter().serialize_instance
-        ret = dict(account=serialize_instance(self.account),
-                   user=serialize_instance(self.user),
-                   state=self.state,
-                   email_addresses=[serialize_instance(ea)
-                                    for ea in self.email_addresses])
-        if self.token:
-            ret['token'] = serialize_instance(self.token)
-        return ret
-
-    @classmethod
-    def deserialize(cls, data):
-        deserialize_instance = get_adapter().deserialize_instance
-        account = deserialize_instance(SocialAccount, data['account'])
-        user = deserialize_instance(get_user_model(), data['user'])
-        if 'token' in data:
-            token = deserialize_instance(SocialToken, data['token'])
-        else:
-            token = None
-        email_addresses = []
-        for ea in data['email_addresses']:
-            email_address = deserialize_instance(EmailAddress, ea)
-            email_addresses.append(email_address)
-        ret = cls()
-        ret.token = token
-        ret.account = account
-        ret.user = user
-        ret.email_addresses = email_addresses
-        ret.state = data['state']
-        return ret
-
-    def save(self, request, connect=False):
-        """
-        Saves a new account. Note that while the account is new,
-        the user may be an existing one (when connecting accounts)
-        """
-        assert not self.is_existing
-        user = self.user
-        user.save()
-        self.account.user = user
-        self.account.save()
-        if app_settings.STORE_TOKENS and self.token:
-            self.token.account = self.account
-            self.token.save()
-        if connect:
-            # TODO: Add any new email addresses automatically?
-            pass
-        else:
-            setup_user_email(request, user, self.email_addresses)
-
-    @property
-    def is_existing(self):
-        """
-        Account is temporary, not yet backed by a database record.
-        """
-        return self.account.pk is not None
-
-    def lookup(self):
-        """
-        Lookup existing account, if any.
-        """
-        assert not self.is_existing
-        try:
-            a = SocialAccount.objects.get(provider=self.account.provider,
-                                          uid=self.account.uid)
-            # Update account
-            a.extra_data = self.account.extra_data
-            self.account = a
-            self.user = self.account.user
-            a.save()
-            # Update token
-            if app_settings.STORE_TOKENS and self.token:
-                assert not self.token.pk
-                try:
-                    t = SocialToken.objects.get(account=self.account,
-                                                app=self.token.app)
-                    t.token = self.token.token
-                    if self.token.token_secret:
-                        # only update the refresh token if we got one
-                        # many oauth2 providers do not resend the refresh token
-                        t.token_secret = self.token.token_secret
-                    t.expires_at = self.token.expires_at
-                    t.save()
-                    self.token = t
-                except SocialToken.DoesNotExist:
-                    self.token.account = a
-                    self.token.save()
-        except SocialAccount.DoesNotExist:
-            pass
-
-    def get_redirect_url(self, request):
-        url = self.state.get('next')
-        return url
-
-    @classmethod
-    def state_from_request(cls, request):
-        state = {}
-        next_url = get_next_redirect_url(request)
-        if next_url:
-            state['next'] = next_url
-        state['process'] = get_request_param(request, 'process', 'login')
-        state['scope'] = get_request_param(request, 'scope', '')
-        state['auth_params'] = get_request_param(request, 'auth_params', '')
-        return state
-
-    @classmethod
-    def stash_state(cls, request):
-        state = cls.state_from_request(request)
-        verifier = get_random_string()
-        request.session['socialaccount_state'] = (state, verifier)
-        return verifier
-
-    @classmethod
-    def unstash_state(cls, request):
-        if 'socialaccount_state' not in request.session:
-            raise PermissionDenied()
-        state, verifier = request.session.pop('socialaccount_state')
-        return state
-
-    @classmethod
-    def verify_and_unstash_state(cls, request, verifier):
-        if 'socialaccount_state' not in request.session:
-            raise PermissionDenied()
-        state, verifier2 = request.session.pop('socialaccount_state')
-        if verifier != verifier2:
-            raise PermissionDenied()
-        return state
+## ... source file continues with no further ForeignKey examples ...
 
 ```
 
diff --git a/content/pages/meta/00-change-log.markdown b/content/pages/meta/00-change-log.markdown
@@ -18,7 +18,7 @@ on GitHub.
 ### December
 * Merged PR [#224](https://github.com/mattmakai/fullstackpython.com/pull/224)
   with information and resources on the Masonite web framework for the
-  [other.web frameworks](/other-web-frameworks.html) page.
+  [other web frameworks](/other-web-frameworks.html) page.
 * Updated the [RQ](/redis-queue-rq.html) page with a couple of new fresh
   resources.
 * Added new Django code example pages:
