def setUp(self):
self.fake_model = CredentialsModel()
self.fake_model_field = self.fake_model._meta.get_field('credentials')
self.field = CredentialsField(null=True)
self.credentials = Credentials()
self.pickle_str = _helpers._from_bytes(
base64.b64encode(pickle.dumps(self.credentials)))
def setUp(self):
self.fake_model = CredentialsModel()
self.fake_model_field = self.fake_model._meta.get_field('credentials')
self.field = CredentialsField(null=True)
self.credentials = Credentials()
self.pickle_str = _from_bytes(
base64.b64encode(pickle.dumps(self.credentials)))
class CPSGoogleCredential(models.Model):
id = models.ForeignKey(CPSStaff, primary_key=True)
credential = CredentialsField()
class Meta:
# maps model to the picmodels module
app_label = 'picmodels'
class CredentialsModel(models.Model):
id = models.ForeignKey(Navigators, primary_key=True)
credential = CredentialsField()
class Meta:
# maps model to the picmodels module
app_label = 'picmodels'
class GoogleCredentials(models.Model):
"""
Model to store google credentioal
(found in best practices for google api + django)
"""
user = models.OneToOneField(User, primary_key=True, related_name='google_credential')
credential = CredentialsField()
class Migration(migrations.Migration):
dependencies = [
('googledrive_integration', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='googledriveusertoken',
name='credential',
field=CredentialsField(null=True),
),
migrations.RunPython(create_credential_model),
migrations.RemoveField(
model_name='googledriveusertoken',
name='refresh_token',
),
migrations.RemoveField(
model_name='googledriveusertoken',
name='scopes',
),
migrations.RemoveField(
model_name='googledriveusertoken',
name='token',
),
migrations.RemoveField(
model_name='googledriveusertoken',
name='token_uri',
),
]
class Credentials(models.Model):
#id = models.ForeignKey(User, on_delete=models.CASCADE, primary_key=True, related_name='credential')
id = models.OneToOneField(User,
on_delete=models.CASCADE,
primary_key=True,
related_name='credential')
credential = CredentialsField()
class UserProfile(models.Model):
user = models.ForeignKey(User)
department = models.ForeignKey(Department, blank=True, null=True)
majors = models.ManyToManyField(Department, related_name='major_user_set') # 복수전공들 index 0가
minors = models.ManyToManyField(Department, related_name='minor_user_set') # 부전공.
specialized_major = models.ManyToManyField(Department, related_name = 'specialized_major_user_set') # 심화전공.
email = models.EmailField(max_length=255, blank=True, null=True) # Email
student_id = models.CharField(max_length=10, db_index = True)
sid = models.CharField(max_length=30) # 서비스에 대해 고유하게 부여받은 ID
language = models.CharField(max_length=15)
favorite_departments = models.ManyToManyField('subject.Department', related_name='favoredby_set')
take_lecture_list = models.ManyToManyField('subject.Lecture', related_name='take_lecture_list', blank=True)
portal_check = models.IntegerField(default=0)
google_calendar_id = models.TextField(null=True, blank=True)
google_credential = CredentialsField()
point = 0
point_updated_time = None
def get_point(self):
self.point = sso_client.get_point(self.sid)
return self.point
def add_point(self, delta, message):
result = sso_client.modify_point(self.sid, delta, message, 0)
return result
def __unicode__(self):
return u'%s %s' % (self.user.username, self.student_id)
class GoogleCredential(models.Model):
credentials = CredentialsField()
user = models.ForeignKey(User)
email = models.EmailField(unique=True)
def __unicode__(self):
return self.email
class FakeCredentialsModelMockNoSet(object):
def __init__(self, set_store=False, *args, **kwargs):
self.model = FakeCredentialsModelMock
self.saved = False
self.deleted = False
credentials = CredentialsField()
class SessId(models.Model):
session = models.CharField(max_length=80, null=True)
access_code = models.CharField(max_length=80, null=True)
#http = models.CharField(max_length = 300, null = True)
credential = CredentialsField()
def __str__(self):
return self.access_code
class CredentialsModel(models.Model):
id = models.ForeignKey(User, primary_key = True, on_delete = models.CASCADE)
credential = CredentialsField()
task = models.CharField(max_length=80, null = True)
updated_time = models.CharField(max_length = 80, null = True)
def __unicode__(self):
return self.id +' '+ self.updated_time
class CredentialsModel(models.Model):
credentials = CredentialsField()
id = models.OneToOneField(User, primary_key=True)
class Meta:
db_table = 'credentials'
def __str__(self):
return 'creds'
class CredentialsModel(models.Model):
id = models.OneToOneField(settings.AUTH_USER_MODEL, primary_key=True, related_name='credentials')
credential = CredentialsField()
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
class CredentialsModel(models.Model):
id = models.ForeignKey(User, primary_key=True, on_delete=models.CASCADE)
credential = CredentialsField()
task = models.CharField(max_length=80, null=True)
email = models.CharField(max_length=80, null=True)
username = models.CharField(max_length=80, null=True)
#新增
# nickname = models.CharField(max_length=30)
user_image = models.ImageField(upload_to='media/image/',
default="image/photo.png")
class TokenStorageModel(models.Model):
"""
Google Auth Token storage model
"""
id = models.OneToOneField(settings.AUTH_USER_MODEL,
primary_key=True, related_name='google_id')
credential = CredentialsField()
class Meta:
app_label = 'main'
class Group(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
user = models.ForeignKey(User, on_delete=models.CASCADE, editable=False)
displayName = models.CharField(max_length=128)
token = CredentialsField(
editable=False,
blank=True,
null=True,
)
def __str__(self):
return self.displayName
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
google_oauth = CredentialsField()
default_title = models.CharField(max_length=100, blank=True)
default_album = models.CharField(max_length=100, blank=True)
default_composer = models.CharField(max_length=100, blank=True)
default_genre = models.CharField(max_length=100, blank=True)
default_language = models.CharField(max_length=100, blank=True)
default_artist = models.CharField(max_length=100, blank=True)
default_album_artist = models.CharField(max_length=100, blank=True)
def __str__(self):
return self.user.username
class Subscription(models.Model):
SUBSCRIPTION_MONTHLY = 1
SUBSCRIPTION_YEARLY = 2
SUBSCRIPTION_TYPE = (
(SUBSCRIPTION_MONTHLY, 'Monthly'),
(SUBSCRIPTION_YEARLY, 'Yearly'),
)
user = models.OneToOneField(SiteUser)
subscription_type = models.SmallIntegerField(choices=SUBSCRIPTION_TYPE)
active = models.BooleanField(default=False)
created = models.DateTimeField(auto_now_add=True)
vimeo_token = models.CharField(max_length=500, blank=True, null=True)
vimeo_scope = models.CharField(max_length=500, blank=True, null=True)
youtube_credentials = CredentialsField(blank=True, null=True)
class GoogleDriveUserToken(models.Model):
"""
Represents an OAuth Token for a Google Drive user
"""
user = models.OneToOneField(settings.AUTH_USER_MODEL,
related_name='googledrive_user_token')
credential = CredentialsField()
@property
def client(self):
if not self.credential.valid:
request = Request()
self.credential.refresh(request)
drive = discovery.build('drive', 'v3', credentials=self.credential)
return drive
def test_authorized_user_not_logged_in_redirects(self):
request = self.factory.get('oauth2/oauth2authorize',
data={'return_url': '/return_endpoint'})
request.session = self.session
authorized_user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
credentials = CredentialsField()
CredentialsModel.objects.create(user_id=authorized_user,
credentials=credentials)
request.user = authorized_user
response = views.oauth2_authorize(request)
self.assertIsInstance(response, http.HttpResponseRedirect)
class SiteUser(models.Model):
user = models.OneToOneField(
User, on_delete=models.CASCADE
) # Using Django default model for authentication
credential = CredentialsField()
name = models.CharField(max_length=50)
# user type can be either salesman or customer so used boolean field
is_salesman = models.BooleanField(choices=[(True, 'yes'), (False, 'no')])
timezone = models.CharField(max_length=50, default="UTC")
notification_enabled = models.BooleanField(default=False)
notification_channel_id = models.TextField(unique=True,
blank=True,
null=True)
def __str__(self):
return self.name
class TestCredentialsField(unittest2.TestCase):
def setUp(self):
self.fake_model = CredentialsModel()
self.fake_model_field = self.fake_model._meta.get_field('credentials')
self.field = CredentialsField(null=True)
self.credentials = Credentials()
self.pickle_str = _from_bytes(
base64.b64encode(pickle.dumps(self.credentials)))
def test_field_is_text(self):
self.assertEqual(self.field.get_internal_type(), 'BinaryField')
def test_field_unpickled(self):
self.assertIsInstance(
self.field.to_python(self.pickle_str), Credentials)
def test_field_already_unpickled(self):
self.assertIsInstance(
self.field.to_python(self.credentials), Credentials)
def test_none_field_unpickled(self):
self.assertIsNone(self.field.to_python(None))
def test_from_db_value(self):
value = self.field.from_db_value(
self.pickle_str, None, None, None)
self.assertIsInstance(value, Credentials)
def test_field_unpickled_none(self):
self.assertEqual(self.field.to_python(None), None)
def test_field_pickled(self):
prep_value = self.field.get_db_prep_value(self.credentials,
connection=None)
self.assertEqual(prep_value, self.pickle_str)
def test_field_value_to_string(self):
self.fake_model.credentials = self.credentials
value_str = self.fake_model_field.value_to_string(self.fake_model)
self.assertEqual(value_str, self.pickle_str)
def test_field_value_to_string_none(self):
self.fake_model.credentials = None
value_str = self.fake_model_field.value_to_string(self.fake_model)
self.assertIsNone(value_str)
def test_credentials_without_null(self):
credentials = CredentialsField()
self.assertTrue(credentials.null)
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Forward',
fields=[
('id',
models.AutoField(verbose_name='ID',
serialize=False,
auto_created=True,
primary_key=True)),
('email', models.EmailField(max_length=254)),
('response', models.TextField()),
],
),
migrations.CreateModel(
name='GoogleCredential',
fields=[
('id',
models.AutoField(verbose_name='ID',
serialize=False,
auto_created=True,
primary_key=True)),
('credentials', CredentialsField(null=True)),
('user',
models.ForeignKey(to=settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)),
],
),
migrations.AddField(
model_name='forward',
name='credentials',
field=models.ForeignKey(to='autorespond.GoogleCredential',
on_delete=models.CASCADE),
),
migrations.AddField(
model_name='forward',
name='user',
field=models.ForeignKey(to=settings.AUTH_USER_MODEL,
on_delete=models.CASCADE),
),
]
class TestCredentialsField(unittest2.TestCase):
def setUp(self):
self.fake_model = CredentialsModel()
self.fake_model_field = self.fake_model._meta.get_field('credentials')
self.field = CredentialsField(null=True)
self.credentials = Credentials()
self.pickle_str = _helpers._from_bytes(
base64.b64encode(pickle.dumps(self.credentials)))
def test_field_is_text(self):
self.assertEqual(self.field.get_internal_type(), 'BinaryField')
def test_field_unpickled(self):
self.assertIsInstance(self.field.to_python(self.pickle_str),
Credentials)
def test_field_already_unpickled(self):
self.assertIsInstance(self.field.to_python(self.credentials),
Credentials)
def test_none_field_unpickled(self):
self.assertIsNone(self.field.to_python(None))
def test_from_db_value(self):
value = self.field.from_db_value(self.pickle_str, None, None, None)
self.assertIsInstance(value, Credentials)
def test_field_unpickled_none(self):
self.assertEqual(self.field.to_python(None), None)
def test_field_pickled(self):
prep_value = self.field.get_db_prep_value(self.credentials,
connection=None)
self.assertEqual(prep_value, self.pickle_str)
def test_field_value_to_string(self):
self.fake_model.credentials = self.credentials
value_str = self.fake_model_field.value_to_string(self.fake_model)
self.assertEqual(value_str, self.pickle_str)
def test_field_value_to_string_none(self):
self.fake_model.credentials = None
value_str = self.fake_model_field.value_to_string(self.fake_model)
self.assertIsNone(value_str)
def test_credentials_without_null(self):
credentials = CredentialsField()
self.assertTrue(credentials.null)
class Migration(migrations.Migration):
dependencies = [
('api', '0010_event_active'),
]
operations = [
migrations.AddField(
model_name='andelauserprofile',
name='credential',
field=CredentialsField(null=True),
),
migrations.AddField(
model_name='andelauserprofile',
name='state',
field=models.CharField(blank=True, max_length=80),
),
]
class Migration(migrations.Migration):
dependencies = [
('auth', '0006_require_contenttypes_0002'),
]
operations = [
migrations.CreateModel(
name='CredentialsModel',
fields=[
('id',
models.OneToOneField(primary_key=True,
to=settings.AUTH_USER_MODEL,
serialize=False)),
('credential', CredentialsField(null=True)),
],
),
]
class FakeCredentialsModel(models.Model):
credentials = CredentialsField()
class CredentialsModel(models.Model):
id = models.ForeignKey(User, primary_key=True)
credential = CredentialsField()
class CredetialsModel(models.Model):
user_id = models.OneToOneField(User,
on_delete=models.DO_NOTHING,
null=True)
credential = CredentialsField()
class CredentialsModel(models.Model):
id = models.ForeignKey(User, primary_key=True, on_delete=models.CASCADE)
credential = CredentialsField()
task = models.CharField(max_length=80, null=True)
updated_time = models.CharField(max_length=80, null=True)
class Credentials(models.Model):
id = models.OneToOneField(User, on_delete=models.CASCADE, primary_key=True)
credential = CredentialsField()
def __unicode__(self):
return self