Source Code for Module oauth2client.django_orm

  1  # Copyright (C) 2010 Google Inc. 
  2  # 
  3  # Licensed under the Apache License, Version 2.0 (the "License"); 
  4  # you may not use this file except in compliance with the License. 
  5  # You may obtain a copy of the License at 
  6  # 
  7  #      http://www.apache.org/licenses/LICENSE-2.0 
  8  # 
  9  # Unless required by applicable law or agreed to in writing, software 
 10  # distributed under the License is distributed on an "AS IS" BASIS, 
 11  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 12  # See the License for the specific language governing permissions and 
 13  # limitations under the License. 
 14   
 15  """OAuth 2.0 utilities for Django. 
 16   
 17  Utilities for using OAuth 2.0 in conjunction with 
 18  the Django datastore. 
 19  """ 
 20   
 21  __author__ = 'jcgregorio@google.com (Joe Gregorio)' 
 22   
 23  import oauth2client 
 24  import base64 
 25  import pickle 
 26   
 27  from django.db import models 
 28  from oauth2client.client import Storage as BaseStorage 
 29   
 30 -class CredentialsField(models.Field): 
 31   
 32    __metaclass__ = models.SubfieldBase 
 33   
 34 -  def __init__(self, *args, **kwargs): 
 35      if 'null' not in kwargs: 
 36        kwargs['null'] = True 
 37      super(CredentialsField, self).__init__(*args, **kwargs) 
 38   
 39 -  def get_internal_type(self): 
 40      return "TextField" 
 41   
 42 -  def to_python(self, value): 
 43      if value is None: 
 44        return None 
 45      if isinstance(value, oauth2client.client.Credentials): 
 46        return value 
 47      return pickle.loads(base64.b64decode(value)) 
 48   
 49 -  def get_db_prep_value(self, value, connection, prepared=False): 
 50      if value is None: 
 51        return None 
 52      return base64.b64encode(pickle.dumps(value)) 
 53   
 54   
 55 -class FlowField(models.Field): 
 56   
 57    __metaclass__ = models.SubfieldBase 
 58   
 59 -  def __init__(self, *args, **kwargs): 
 60      if 'null' not in kwargs: 
 61        kwargs['null'] = True 
 62      super(FlowField, self).__init__(*args, **kwargs) 
 63   
 64 -  def get_internal_type(self): 
 65      return "TextField" 
 66   
 67 -  def to_python(self, value): 
 68      if value is None: 
 69        return None 
 70      if isinstance(value, oauth2client.client.Flow): 
 71        return value 
 72      return pickle.loads(base64.b64decode(value)) 
 73   
 74 -  def get_db_prep_value(self, value, connection, prepared=False): 
 75      if value is None: 
 76        return None 
 77      return base64.b64encode(pickle.dumps(value)) 
 78   
 79   
 80 -class Storage(BaseStorage): 
 81    """Store and retrieve a single credential to and from 
 82    the datastore. 
 83   
 84    This Storage helper presumes the Credentials 
 85    have been stored as a CredenialsField 
 86    on a db model class. 
 87    """ 
 88   
 89 -  def __init__(self, model_class, key_name, key_value, property_name): 
 90      """Constructor for Storage. 
 91   
 92      Args: 
 93        model: db.Model, model class 
 94        key_name: string, key name for the entity that has the credentials 
 95        key_value: string, key value for the entity that has the credentials 
 96        property_name: string, name of the property that is an CredentialsProperty 
 97      """ 
 98      self.model_class = model_class 
 99      self.key_name = key_name 
100      self.key_value = key_value 
101      self.property_name = property_name 
102   
103 -  def locked_get(self): 
104      """Retrieve Credential from datastore. 
105   
106      Returns: 
107        oauth2client.Credentials 
108      """ 
109      credential = None 
110   
111      query = {self.key_name: self.key_value} 
112      entities = self.model_class.objects.filter(**query) 
113      if len(entities) > 0: 
114        credential = getattr(entities[0], self.property_name) 
115        if credential and hasattr(credential, 'set_store'): 
116          credential.set_store(self) 
117      return credential 
118   
119 -  def locked_put(self, credentials): 
120      """Write a Credentials to the datastore. 
121   
122      Args: 
123        credentials: Credentials, the credentials to store. 
124      """ 
125      args = {self.key_name: self.key_value} 
126      entity = self.model_class(**args) 
127      setattr(entity, self.property_name, credentials) 
128      entity.save() 
129   
130 -  def locked_delete(self): 
131      """Delete Credentials from the datastore.""" 
132   
133      query = {self.key_name: self.key_value} 
134      entities = self.model_class.objects.filter(**query).delete() 
135