class Tutor(models.Model):
profile = AutoOneToOneField(Profile,
primary_key=True,
on_delete=models.CASCADE,
null=False)
bio = models.TextField(default='')
exp = models.TextField(default='')
lectures = models.ManyToManyField(Lecture)
times = AutoOneToOneField(Times,
on_delete=models.CASCADE,
null=False,
related_name='times',
default=default_times)
tutoringTimes = AutoOneToOneField(Times,
on_delete=models.CASCADE,
null=False,
related_name='tutoringTimes',
default=default_times)
# 1 when tutoring at that time, 0 otherwise
class Meta:
ordering = [
'profile__name',
]
class Owner(models.Model):
# determines the base cost of interactions based on the savings goal
@property
def baseCost(self):
goal = self.goal * 100
days = 30
vFactor = 10
tFactor = 3
fFactor = 1
vet = 1
toy = 4
food = days - vet - toy
factor = (food * fFactor + toy * tFactor + vet * vFactor)
remainder = goal % factor
baseCost = (goal - remainder) / factor
# The returned value is the amount * 100, so that there are never any issues with double/float rounding
# e.g., $2.12 -> 212
return baseCost
# determines the random interaction order of the month
@property
def interactionOrder(self):
import random
order = 'F' * 25
order = order + 'T' * 4
order = order + 'V'
return ''.join(random.sample(order, len(order)))
user = AutoOneToOneField(User, on_delete=models.CASCADE)
pet = AutoOneToOneField(Pet, on_delete=models.CASCADE, null=True)
numPets = models.PositiveIntegerField(default=1)
goal = models.PositiveIntegerField(default=100)
progress = models.IntegerField(default=0)
checkNum = models.CharField(max_length=9, default="123456780")
saveNum = models.CharField(max_length=9, default="123456781")
routeNum = models.CharField(max_length=9, default="222222226")
_interactionOrder = property(interactionOrder)
_baseCost = property(baseCost)
numTrans = models.PositiveIntegerField(default=0)
lastPay = models.CharField(max_length=30, blank=True, null=True)
address = models.CharField(max_length=100, default="123 Test")
city = models.CharField(max_length=100, default="Princeton")
state = models.CharField(max_length=100, default="NJ")
postalcode = models.CharField(max_length=5, default="08544")
dob = models.CharField(max_length=10, default="1995-01-01")
ssn = models.CharField(max_length=15, default="1234")
phone = models.CharField(max_length=15, default="1234567890")
custDwolla = models.CharField(max_length=100, null=True)
checkSource = models.CharField(max_length=100, null=True)
saveSource = models.CharField(max_length=100, null=True)
class UserProfile(models.Model):
"""User profile
Auto-created when accessed via a RelatedManager
"""
ASK = 0
DISPLAY = 1
NO_DISPLAY = 2
IMAGE_OPTIONS = (
(ASK, _("Always ask to display images")),
(DISPLAY, _("Always display images")),
(NO_DISPLAY, _("Never display images")),
)
user = AutoOneToOneField(settings.AUTH_USER_MODEL,
primary_key=True,
related_name="inboxenprofile")
flags = BitField(flags=("prefer_html_email", "unified_has_new_messages",
"ask_images", "display_images"),
default=5)
prefered_domain = models.ForeignKey("inboxen.Domain",
null=True,
blank=True)
prefer_html_email = models.BooleanField(default=True)
unified_has_new_messages = models.BooleanField(default=False)
display_images = models.PositiveSmallIntegerField(choices=IMAGE_OPTIONS,
default=ASK)
def __str__(self):
return u"Profile for %s" % self.user
class Favorites(models.Model):
user = AutoOneToOneField(User,
primary_key=True,
related_name="favorites",
on_delete=models.CASCADE)
bounties = models.ManyToManyField(Bounty, blank=True)
portfolios = models.ManyToManyField(Portfolio, blank=True)
class Liberation(models.Model):
"""Liberation data
`async_result` is the UUID of Celery result object, which may or may not be valid
`_path` is relative to settings.LIBERATION_PATH
"""
user = AutoOneToOneField(settings.AUTH_USER_MODEL, primary_key=True)
flags = BitField(flags=("running", "errored"), default=0)
content_type = models.PositiveSmallIntegerField(default=0)
async_result = models.UUIDField(null=True)
started = models.DateTimeField(null=True)
last_finished = models.DateTimeField(null=True)
_path = models.CharField(
max_length=255,
null=True,
unique=True,
validators=[validators.ProhibitNullCharactersValidator()])
def get_path(self):
if self._path is None:
return None
return os.path.join(settings.LIBERATION_PATH, self._path)
def set_path(self, path):
assert path[0] != "/", "path should be relative, not absolute"
self._path = os.path.join(settings.LIBERATION_PATH, path)
path = property(get_path, set_path)
def __str__(self):
return u"Liberation for %s" % self.user
class UserProfile(models.Model):
user = AutoOneToOneField('auth.user')
picture = models.ImageField(upload_to='profile_pictures', blank=True)
bio = models.CharField(max_length = 1000, blank = True)
def __str__(self):
return self.user.username
class Address(models.Model):
user = AutoOneToOneField(get_user_model(), on_delete=models.CASCADE)
city = models.CharField(max_length=30, blank=True)
country = models.CharField(max_length=30, blank=True)
def __str__(self):
return self.city + ', ' + self.country
class Profile(models.Model):
user = AutoOneToOneField(User, primary_key=True, on_delete=models.CASCADE)
email_confirmed = models.BooleanField(default=False)
full_name = models.CharField(max_length=100, null=True, blank=False)
schools = models.ManyToManyField(School, blank=False)
degrees = models.ManyToManyField(Degree, blank=False)
program = models.CharField(max_length=100, null=True, blank=False)
grad_year = models.IntegerField(null=True, blank=False)
resume = models.FileField(upload_to=user_directory_path,
null=True,
blank=True)
viewable = models.BooleanField(default=False)
def resume_basename(self):
return os.path.basename(self.resume.name)
def __str__(self):
try:
if self.full_name is not None:
return "{}'s profile".format(self.full_name)
else:
return "{}'s profile".format(self.user.username)
except:
return "{}'s profile".format(self.user.username)
class Meta:
ordering = ('user', )
class UserProfile(models.Model):
PROFILE_TYPE = (
('audited', 'Organisme Contrôlé'),
('inspector', 'Contrôleur'),
)
user = AutoOneToOneField(
settings.AUTH_USER_MODEL, primary_key=True, on_delete=models.CASCADE,
related_name='profile')
profile_type = models.CharField(max_length=255, choices=PROFILE_TYPE)
controls = models.ManyToManyField(
to='control.Control', verbose_name='controles', related_name='user_profiles', blank=True)
organization = models.CharField("Organisme", max_length=255, blank=True)
send_files_report = models.BooleanField(
verbose_name="Envoie Rapport de Fichiers", default=False,
help_text="Envoyer par email le rapport des fichiers uplodés ?")
objects = UserProfileQuerySet.as_manager()
class Meta:
verbose_name = "Profile Utilisateur"
verbose_name_plural = "Profiles Utilisateurs"
@property
def is_inspector(self):
return self.profile_type == 'inspector'
@property
def is_audited(self):
return self.profile_type == 'audited'
def __str__(self):
return str(self.user)
class Account(models.Model):
owner = AutoOneToOneField('auth.User', related_name='billing_account')
def get_current_subscription(self):
active_statuses = 'pending', 'approved'
active_subs = Subscription.objects. \
filter_by_current_statuses(active_statuses). \
filter(billing_account=self).order_by('-date_created')
subs = active_subs
#subs = self.subscriptions.order_by('-date_created')
r = list(subs[:1])
if r:
return r[0]
return None
def get_current_product(self):
pc = self.get_current_product_class()
if pc:
return pc()
#sub = self.get_current_subscription()
#if sub:
#return sub.get_product()
#return ()
return None
def get_current_product_class(self):
sub = self.get_current_subscription()
if sub:
return sub.get_product_class()
elif hasattr(settings, 'BILLING_DEFAULT_PRODUCT'):
return billing.loading.get_product(
settings.BILLING_DEFAULT_PRODUCT)
return None
def get_processor(self):
return processor_router.get_processor_for_account(self)
def has_valid_billing_details(self):
return self.get_processor().has_valid_billing_details(self)
def subscribe_to_product(self, product):
return Subscription.objects.create_from_product(product, self)
def get_visible_products(self):
""" returns the list of products that is visible to the given account """
all_products = billing.loading.get_products(hidden=True)
public_products = billing.loading.get_products()
subscribed_product_types = ProductType.objects \
.filter(subscriptions__billing_account=self) \
.distinct()
subscribed_products = set(pt.get_product_class()
for pt in subscribed_product_types)
visible_products = set(public_products).union(subscribed_products)
return [p for p in all_products if p in visible_products]
def __unicode__(self):
return "%s's account" % unicode(self.owner)
def __repr__(self):
return "Account(owner=%s)" % repr(self.owner)
class UserSettings(models.Model):
user = AutoOneToOneField(User,
related_name='settings',
unique=True,
db_index=True)
birth_date = models.DateField(_('birth date'), blank=True, null=True)
timezone = timezone_field.TimeZoneField(blank=True,
null=True,
default=None,
verbose_name=_('time zone'))
location_name = models.CharField(_('location'),
blank=True,
default='',
max_length=255)
location_latitude = models.FloatField(null=True, blank=True, default=None)
location_longitude = models.FloatField(null=True, blank=True, default=None)
profile_image = models.ImageField(verbose_name=_('profile image'),
blank=True,
default='',
max_length=255,
upload_to=profile_image_upload_to)
preferred_language = models.CharField(_('language'),
blank=True,
default='',
choices=settings.LANGUAGES,
max_length=32)
class Meta:
verbose_name = _('user settings')
verbose_name_plural = _('user settings')
def __str__(self):
return '{0} ({1})'.format(self.user.username, self.user.pk)
class Profile(PybbProfile):
PROFILE_DATE_SHOW_CLASSIC = 1
PROFILE_DATE_SHOW_REVERTED = 2
PROFILE_DATE_SHOW_TYPES = (
(PROFILE_DATE_SHOW_REVERTED, _(u'Reverted')),
(PROFILE_DATE_SHOW_CLASSIC, _(u'Classic')),
)
user = AutoOneToOneField(MyUser, related_name='profile')
date_show_type = models.IntegerField(verbose_name=_(u'Date show type'), choices=PROFILE_DATE_SHOW_TYPES,
default=PROFILE_DATE_SHOW_REVERTED)
# personal info
icq = models.CharField(verbose_name=_('ICQ Number'), max_length=10, null=True, blank=True,
validators=[RegexValidator(regex='\d+')])
skype = models.CharField(verbose_name=_('Skype username'), max_length=100, null=True, blank=True)
jabber = models.CharField(verbose_name=_('Jabber address'), max_length=100, null=True, blank=True)
site = models.URLField(verbose_name=_('Personal site'), null=True, blank=True)
interests = models.TextField(verbose_name=_('Interests'), null=True, blank=True)
def __unicode__(self):
return self.user.username
def __str__(self):
return self.user.username
class Meta(object):
verbose_name = _('Profile')
verbose_name_plural = _('Profiles')
def get_absolute_url(self):
return reverse('pybb:user', kwargs={'username': self.user.username})
def get_display_name(self):
return self.user.username
class Position(CoordinatesModel, DatetimeModel):
""" Position utilisateur """
# Champs
user = AutoOneToOneField(settings.AUTH_USER_MODEL,
primary_key=True,
related_name='position',
verbose_name=_("User"))
note = models.CharField(max_length=255,
blank=True,
verbose_name=_("Notes"))
objects = PositionManager()
# Getter
def get_close_users(self, km):
"""
Renvoyer les utilisateurs proches à n km
:param km: distance max en km
"""
return Position.get_users_in(self.get_bounding_box(km))
# Overrides
def __str__(self):
""" Renvoyer la représentation unicode de l'objet """
return "{user} @ {gps}".format(user=self.user,
gps=self.get_formatted_coordinates())
# Métadonnées
class Meta:
verbose_name = _("user position")
verbose_name_plural = _("user positioning")
app_label = 'location'
class AppSettings(models.Model):
''' Contains settings chosen for a given app's algorithms
and maybe eventually for other stuff'''
mobile_app = AutoOneToOneField(MobileApp)
likes_sports = models.BooleanField(default=False)
likes_technology = models.BooleanField(default=False)
likes_books = models.BooleanField(default=False)
likes_nature = models.BooleanField(default=False)
likes_games = models.BooleanField(default=False)
likes_restaurants = models.BooleanField(default=False)
likes_music = models.BooleanField(default=False)
POLITICAL_CHOICES = ((0, 'No bias'), (-1, 'Conservative'), (1, 'Liberal'))
political_bias = models.IntegerField(POLITICAL_CHOICES,
blank=True,
null=True)
same_city = models.BooleanField(default=False)
city = models.CharField(max_length=250, null=True, blank=True)
SOCIAL_CIRCLE_CHOICES = (("fa", "Family"), ("co", "Colleagues"),
("colf", "College Friends"),
("hsf", "High School Friends"))
social_circle = models.CharField(choices=SOCIAL_CIRCLE_CHOICES,
max_length=100,
blank=True,
null=True)
def dict_rep(self):
data = {}
class CNSSProfile(models.Model):
form_title = _("CNSS profile")
member = AutoOneToOneField(
to='members.Member',
on_delete=models.CASCADE,
related_name='profile_cnss',
)
title = models.CharField(
max_length=255,
null=True,
blank=True,
verbose_name=_('Title'),
)
occupation = models.CharField(
max_length=511,
null=True,
blank=True,
verbose_name=_('Occupation'),
)
occupational_history = models.TextField(
null=True,
blank=True,
verbose_name=_('Occupational history'),
)
class UserProfile(models.Model):
user = AutoOneToOneField(User,
on_delete=models.CASCADE,
related_name='profile')
has_seen_tour = models.BooleanField(default=False)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
class User(models.Model):
user = AutoOneToOneField(settings.AUTH_USER_MODEL,
null=True,
verbose_name=_('user'))
unique_code = models.CharField(max_length=255,
verbose_name=_('unique code'))
is_authorized = models.BooleanField(default=False,
verbose_name=_('Is authorized'))
@property
def generate_unique_code(self,
size=36,
chars=string.ascii_uppercase + string.digits +
string.ascii_lowercase):
unique_code = ''.join(random.choice(chars) for _ in range(size))
return unique_code
@property
def set_unique_code(self):
self.unique_code = self.generate_unique_code
@property
def check_unique_code(self, code):
if self.unique_code == code:
return True
return False
def save(self, *args, **kwargs):
if not self.pk or not self.unique_code:
self.set_unique_code
return super(User, self).save(*args, **kwargs)
def __str__(self):
return '%s' % str(self.user.username)
class UserProfile(models.Model):
title = (
(0, 'Unrated'),
(1, 'Bronze'),
(2, 'Silver'),
(3, 'Gold'),
(4, 'Platinum'),
)
follows = models.ManyToManyField('self', related_name='follower', symmetrical=False, blank=True)
user = AutoOneToOneField('auth.user',related_name="userprofile")
user_avatar = models.ImageField(upload_to=user_images_path, blank=True, null=True)
title = models.IntegerField(choices=title, default=0)
winnings = models.DecimalField(max_digits=10, decimal_places=2, null=True, blank=True)
issue_upvoted = models.ManyToManyField(Issue, blank=True, related_name="upvoted")
issue_saved = models.ManyToManyField(Issue, blank=True, related_name="saved")
def avatar(self, size=36):
if self.user_avatar:
return self.user_avatar.url
for account in self.user.socialaccount_set.all():
if 'avatar_url' in account.extra_data:
return account.extra_data['avatar_url']
elif 'picture' in account.extra_data:
return account.extra_data['picture']
def __unicode__(self):
return self.user.email
class UserProfile(models.Model):
"""Additional information about a User."""
user = AutoOneToOneField(
'auth.User',
verbose_name=_('User'),
related_name='profile',
)
whitelisted = models.BooleanField(_('Whitelisted'), default=False)
banned = models.BooleanField(_('Banned'), default=False)
homepage = models.CharField(_('Homepage'), max_length=100, blank=True)
allow_ads = models.BooleanField(
_('See paid advertising'),
help_text=_('If unchecked, you will still see community ads.'),
default=True,
)
def __str__(self):
return (ugettext("%(username)s's profile") % {
'username': self.user.username
})
def get_absolute_url(self):
return reverse(
'profiles_profile_detail',
kwargs={'username': self.user.username},
)
class UserProfile(models.Model):
user = AutoOneToOneField(User, on_delete=models.CASCADE)
avatar = models.ImageField(upload_to='user_avatars',
default='user_avatars/default-avatar.jpg')
male = 'Nam'
female = 'Nữ'
gender_choices = ((male, 'Male'), (female, 'Female'))
gender = models.CharField(choices=gender_choices, max_length=10)
dateOfBirth = models.DateField(default=datetime.date.today)
intro = models.TextField(max_length=100, default="")
phone = models.CharField(max_length=15, default="")
follows = models.ManyToManyField("self",
related_name='followers',
symmetrical=False,
blank=True)
favorite_pet = models.ManyToManyField(Pet,
related_name='followers',
blank=True)
liked_images = models.ManyToManyField(PetGallery,
related_name='users_like',
blank=True)
def __str__(self):
return self.user.username
def get_absolute_url(self):
return reverse('pet:user profile', kwargs={'user_id': self.user.id})
class MemberpageProfile(models.Model):
form_title = _("Memberpage settings")
member = AutoOneToOneField(
to='members.Member',
on_delete=models.CASCADE,
related_name='profile_memberpage',
)
secret_token = models.CharField(
max_length=128,
null=True,
blank=True,
default=generate_default_token,
)
is_visible_to_members = models.BooleanField(
default=False,
verbose_name=_('Consent: Visible to other members'),
)
# publication_consent format: {"fields": {"profile_memberpage__secret_token": {"visibility": "share"}}}
publication_consent = JSONField(
default=get_default_consent,
null=True,
blank=True,
)
def get_url(self):
config = Configuration.get_solo()
relative_url = reverse('public:memberpage:member.dashboard',
kwargs={'secret_token': self.secret_token})
if config.public_base_url:
return urljoin(config.public_base_url, relative_url)
else:
return relative_url
class UserProfilePic(models.Model):
user = AutoOneToOneField(User, on_delete=models.CASCADE, null=True)
profile_pic = models.ImageField(default='profile_pictures/avatar.png',
upload_to='profile_pictures')
def __str__(self):
return str(self.user)
class NotificationGroup(models.Model):
"""
Basically, it's a auth.Group table replication, used to give them a weight (note the AutoOneToOneField from Django
annoying to ensure the replication). The auth.Group is not directly overwrite to avoid interferences.
:param notificationgroup : a group from auth.Group through a AutoOneToOneField. Unique.
:param weight : the weight is used to determine priority group when a user belongs to several groups, in order to
avoid notification spam.
"""
class Meta:
default_permissions = (
'list',
'add',
'change',
)
notificationgroup = AutoOneToOneField('auth.Group',
unique=True,
on_delete=models.CASCADE)
weight = models.IntegerField(default=0)
def __str__(self):
"""
When the notification group object is called, e.g. in a template, display self.name instead of "a
NotificationClass object"
:return: the group name saved in auth.Group
"""
return self.notificationgroup.name
class MemberSepa(Auditable, models.Model):
member = AutoOneToOneField(
to='members.Member',
related_name='profile_sepa',
on_delete=models.PROTECT,
)
iban = IBANField(null=True, blank=True, verbose_name="IBAN")
bic = BICField(null=True, blank=True, verbose_name="BIC")
institute = models.CharField(
max_length=255,
null=True, blank=True,
verbose_name="IBAN Institute")
issue_date = models.DateField(
null=True, blank=True,
verbose_name="IBAN Issue Date",
help_text="The issue date of the direct debit mandate. (1970-01-01 means there is no issue date in the database )")
fullname = models.CharField(
null=True, blank=True,
max_length=255, verbose_name="IBAN full name",
help_text="Full name for IBAN account owner")
address = models.CharField(
null=True, blank=True,
max_length=255, verbose_name="IBAN address",
help_text="Address line (e.g. Street / House Number)")
zip_code = models.CharField(
null=True, blank=True,
max_length=20, verbose_name="IBAN zip code",
help_text="ZIP Code")
city = models.CharField(
null=True, blank=True,
max_length=255, verbose_name="IBAN City",)
country = models.CharField(
null=True, blank=True,
max_length=255, default="Deutschland",
verbose_name="IBAN Country",)
mandate_reference = models.CharField(
null=True, blank=True,
max_length=255,
verbose_name="IBAN Mandate Reference",)
mandate_reason = models.CharField(
null=True, blank=True,
max_length=255,
verbose_name="IBAN Mandate Reason",)
form_title = _('SEPA information')
@property
def is_usable(self):
return bool(self.iban and self.bic and self.mandate_reference)
class MdExtension(models.Model):
resource = AutoOneToOneField(ResourceBase, primary_key=True)
elements_xml = models.TextField(null=True, blank=True)
ediversion = models.CharField(max_length=100, null=True, blank=True)
rndt_xml = models.TextField(null=True, blank=True)
fileid = models.IntegerField(null=True, blank=True)
md_language = models.CharField(_('language'),
max_length=3,
choices=ALL_LANGUAGES,
default='ita',
help_text=_('language used for metadata'))
md_date = models.DateTimeField(_('metadata date'),
default=datetime.now,
help_text=_('metadata date'))
contacts = models.ManyToManyField(Profile, through='MultiContactRole')
@property
def ediml_referencesystem(self):
return self.resource.srid.split(':')[1]
@property
def ediml_resource(self):
return '{}{}'.format(settings.SITEURL[:-1],
self.resource.get_absolute_url())
@property
def rndt_xml_clean(self):
if self.rndt_xml and self.rndt_xml != '':
return self.rndt_xml.replace(
'<?xml version="1.0" encoding="UTF-8"?>', '')
return None
class SocialNetworks(models.Model):
user = AutoOneToOneField(User,
blank=True,
default=None,
null=True,
related_name='social_networks')
vk = models.CharField(validators=[URLValidator()],
max_length=128,
blank=True,
default=None,
null=True)
fb = models.CharField(validators=[URLValidator()],
max_length=128,
blank=True,
default=None,
null=True)
tw = models.CharField(validators=[URLValidator()],
max_length=128,
blank=True,
default=None,
null=True)
go = models.CharField(validators=[URLValidator()],
max_length=128,
blank=True,
default=None,
null=True)
class Meta:
verbose_name = 'Cоцcети юзера'
verbose_name_plural = 'Cоцcети юзеров'
def __str__(self):
return str(self.user) + '\'s Social Networks'
class Parser(models.Model):
name = models.CharField('name', max_length=50, primary_key=True)
config = models.TextField('config',
max_length=1024,
default='{}',
blank=False)
task = AutoOneToOneField(PeriodicTask, blank=False, null=True)
class Meta:
verbose_name = 'Parser'
verbose_name_plural = 'Parsers'
def __str__(self):
return 'Parser ({})'.format(self.name)
def save(self, **kwargs):
if not self.task:
task = PeriodicTask(
name='{} Parser Task'.format(self.name.title()))
task.task = 'parse.' + self.name.lower()
task.enabled = False
task.save()
self.task = task
models.Model.save(self, **kwargs)
def get_config(self):
try:
return loads(self.config)
except:
return {}
class MemberpageProfile(models.Model):
form_title = _("Memberpage settings")
member = AutoOneToOneField(
to='members.Member',
on_delete=models.CASCADE,
related_name='profile_memberpage',
)
secret_token = models.CharField(
max_length=128,
null=True,
blank=True,
default=generate_default_token,
)
visible_consent = models.BooleanField(
default=False,
verbose_name=_('Consent: Visible to other members'),
)
def get_url(self):
config = MemberpageConfiguration.get_solo()
relative_url = reverse(
'plugins:byro_memberpage:unprotected:memberpage.dashboard',
kwargs={'secret_token': self.secret_token})
if config.external_base_url:
return urljoin(config.external_base_url, relative_url)
else:
return relative_url
class Configuration(models.Model):
user = AutoOneToOneField('auth.User')
host = models.CharField(max_length=255, null=True, blank=True)
port = models.IntegerField(default=993)
username = models.CharField(max_length=255, null=True, blank=True)
password = models.CharField(max_length=255, null=True, blank=True)
class Profile(models.Model):
user = AutoOneToOneField(User)
name = models.CharField(max_length=200, blank=True)
profile_image = models.URLField(blank=True)
data = JSONField(default={})
def update_social_auth_data(self, backend, data):
try:
if 'social_auth_data' not in self.data:
self.data['social_auth_data'] = {}
if isinstance(data, dict):
self.data['social_auth_data'][backend.name] = data
if backend.name == 'twitter':
self.profile_image = data['profile_image_url']
self.name = data['name']
elif backend.name == 'facebook':
self.name = data['name']
self.profile_image = 'http://graph.facebook.com/%s/picture' % data[
'id']
elif self.user.email and not self.profile_image:
self.profile_image = 'http://www.gravatar.com/avatar/' + hashlib.md5(
self.user.email).hexdigest()
self.save()
except Exception as e:
logging.exception(e)
def __unicode__(self):
return self.name
