class userStripe(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL)
stripe_id = models.CharField(max_length=200, null=True, blank=True)
def __unicode__(self):
if self.stripe_id:
return str(self.stripe_id)
else:
return self.user.username
def stripeCallback(sender, request, user, **kwargs):
user_stripe_account, created = userStripe.objects.get_or_create(
user=user)
if created:
print('created for %s' % (user.username))
if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '':
new_stripe_id = stripe.Customer.create(email=user.email)
user_stripe_account.stripe_id = new_stripe_id['id']
user_stripe_account.save()
def profileCallback(sender, request, user, **kwargs):
userProfile, is_created = userStripe.objects.get_or_create(user=user)
if is_created:
userProfile.name = user.username
userProfile.save()
user_logged_in.connect(stripeCallback)
user_signed_up.connect(stripeCallback)
user_signed_up.connect(profileCallback)
def ready(self):
from actstream import registry
registry.register(self.get_model('User'))
from allauth.account.signals import user_logged_in, user_signed_up
from .receivers import update_joined, update_last_login
user_signed_up.connect(update_joined)
user_logged_in.connect(update_last_login)
def ready(self):
""" Connect relevant signals to their corresponding handlers. """
social_account_added.connect(
signals.update_user_email_addresses,
dispatch_uid=str(uuid4()),
weak=False
)
user_signed_up.connect(
signals.notify_admins_new_signup,
dispatch_uid=str(uuid4()),
weak=False
)
def test_user_signed_up_signal(self):
sent_signals = []
def on_signed_up(sender, request, user, **kwargs):
sociallogin = kwargs["sociallogin"]
self.assertEqual(sociallogin.account.provider, GoogleProvider.id)
self.assertEqual(sociallogin.account.user, user)
sent_signals.append(sender)
user_signed_up.connect(on_signed_up)
self.login(self.get_mocked_response(verified_email=True))
self.assertTrue(len(sent_signals) > 0)
def test_user_signed_up_signal(self, mock_login_signal):
sent_signals = []
def on_signed_up(sender, request, user, **kwargs):
sociallogin = kwargs["sociallogin"]
self.assertEqual(sociallogin.account.provider, PEAMUProvider.id)
self.assertEqual(sociallogin.account.user, user)
sent_signals.append(sender)
user_signed_up.connect(on_signed_up)
self.login(self.get_mocked_response())
self.assertEqual(mock_login_signal.call_count, 1)
self.assertTrue(len(sent_signals) > 0)
def ready(self) -> None:
super().ready()
update_dynamic_preferences()
password_changed.connect(ldap_change_password)
password_reset.connect(ldap_change_password)
password_set.connect(ldap_change_password)
user_signed_up.connect(ldap_create_user)
from django_auth_ldap.backend import populate_user # noqa
populate_user.connect(ldap_sync_user_on_login)
def ready(self):
from allauth.account.signals import user_signed_up, user_logged_in
from django.conf.global_settings import AUTH_USER_MODEL
from django.db.models.signals import post_save
from main.signals import set_blank_location, user_signed_up_, check_if_userlocation, user_logged_in_, \
create_auth_token
from main.utils import create_profile
user_signed_up.connect(receiver=set_blank_location)
user_signed_up.connect(receiver=user_signed_up_)
user_logged_in.connect(receiver=check_if_userlocation)
post_save.connect(receiver=create_profile, sender=AUTH_USER_MODEL)
user_logged_in.connect(receiver=user_logged_in_)
post_save.connect(receiver=create_auth_token, sender=AUTH_USER_MODEL)
def ready(self):
super(UserConfig, self).ready()
# the user signal handlers to connect to
User = self.get_model("User")
signals.post_save.connect(self.on_user_save, sender=User, dispatch_uid="users.user.post_save")
user_signed_up.connect(self.on_user_signed_up)
email_confirmed.connect(self.on_email_confirmed)
social_account_removed.connect(self.on_social_account_removed)
# the user ban signal handlers to connect to
UserBan = self.get_model("UserBan")
signals.post_save.connect(self.on_ban_save, sender=UserBan, dispatch_uid="users.user_ban.save")
signals.post_delete.connect(self.on_ban_delete, sender=UserBan, dispatch_uid="users.user_ban.delete")
def test_user_signed_up_signal(self):
sent_signals = []
def on_signed_up(sender, request, user, **kwargs):
sociallogin = kwargs['sociallogin']
self.assertEqual(sociallogin.account.provider,
GoogleProvider.id)
self.assertEqual(sociallogin.account.user,
user)
sent_signals.append(sender)
user_signed_up.connect(on_signed_up)
self.login(self.get_mocked_response(verified_email=True))
self.assertTrue(len(sent_signals) > 0)
def ready(self):
# Deve-se imortar daqui para evitar erro de Modelos ainda não carregdos no setup do Django
from django.db.models.signals import pre_save, post_save
from allauth.account.signals import user_signed_up
from .signals import my_user_signed_up, voluntario_post_save, entidade_pre_save, entidade_post_save
# Conexão de sinais
user_signed_up.connect(my_user_signed_up)
post_save.connect(voluntario_post_save, sender='vol.Voluntario')
pre_save.connect(entidade_pre_save, sender='vol.Entidade')
pre_save.connect(entidade_pre_save,
sender='vol.EntidadeAguardandoAprovacao')
post_save.connect(entidade_post_save, sender='vol.Entidade')
post_save.connect(entidade_post_save,
sender='vol.EntidadeAguardandoAprovacao')
def ready(self):
user_signed_up.connect(log_user_signed_up,
dispatch_uid="user_signed_up")
email_confirmed.connect(log_email_confirmed,
dispatch_uid="email_confirmed")
from allauth.account.models import EmailAddress
post_save.connect(handle_email_created,
sender=EmailAddress,
dispatch_uid="email_created")
from mainsite.signals import handle_token_save
from mainsite.models import AccessTokenProxy
from oauth2_provider.models import AccessToken
post_save.connect(handle_token_save,
sender=AccessToken,
dispatch_uid="token_saved")
post_save.connect(handle_token_save,
sender=AccessTokenProxy,
dispatch_uid="token_proxy_saved")
def ready(self):
super(UserConfig, self).ready()
# the user signal handlers to connect to
User = self.get_model('User')
signals.post_save.connect(self.on_user_save,
sender=User,
dispatch_uid='users.user.post_save')
user_signed_up.connect(self.on_user_signed_up)
email_confirmed.connect(self.on_email_confirmed)
social_account_removed.connect(self.on_social_account_removed)
# the user ban signal handlers to connect to
UserBan = self.get_model('UserBan')
signals.post_save.connect(self.on_ban_save,
sender=UserBan,
dispatch_uid='users.user_ban.save')
signals.post_delete.connect(self.on_ban_delete,
sender=UserBan,
dispatch_uid='users.user_ban.delete')
def test_user_signed_up_signal(self):
self.signal_was_called = False
def handler(sender, **kwargs):
self.signal_was_called = True
user_signed_up.connect(handler)
data = {
# 'first_name': 'Testing',
# 'last_name': 'Signup',
# 'birthday': '11/12/90',
# 'state': 'CO',
'email': '*****@*****.**',
'email2': '*****@*****.**',
'password1': 'mytestpassword2',
'password2': 'mytestpassword2',
}
response = self.client.post('/accounts/signup/', data)
self.assertTrue(self.signal_was_called)
user_signed_up.disconnect(handler)
class userStripe(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE)
stripe_id = models.CharField(max_length=200, null=True, blank=True)
def __unicode__(self):
# Если есть ID, преобразуй в его в строку:
if self.stripe_id:
return str(self.stripe_id)
# Иначе верни имя пользователя:
else:
return self.user.username
def stripeCallback(sender, request, user, **kwargs):
user_stripe_account, created = userStripe.objects.get_or_create(
user=user)
# Если Stripe пользователя создан, появляется его профиль.
if created:
print(f'created for {user.username}')
# Если ID системы stripe не существует, то используй email пользователя для его создания:
if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '':
new_stripe_id = stripe.Customer.create(email=user.email)
user_stripe_account.stripe_id = new_stripe_id['id']
user_stripe_account.save()
def profileCallback(sender, request, user, **kwargs):
userProfile, is_created = Profile.objects.get_or_create(user=user)
# Если пользователь создан, появляется его профиль.
if is_created:
userProfile.name = user.username
userProfile.save()
user_logged_in.connect(stripeCallback)
user_signed_up.connect(stripeCallback)
user_signed_up.connect(profileCallback)
from allauth.account.signals import user_signed_up
from actions.utils import create_action
from .models import Profile
def user_created(request, user, **kwargs):
""" Creates empty user profile when a new user signs up """
Profile.objects.create(user=user)
create_action(user, "has signed up")
user_signed_up.connect(user_created)
""" Users models """
# -*- coding: utf-8 -*-
from django.contrib.auth.models import AbstractUser
#from django.utils.translation import ugettext_lazy as _
from allauth.account.signals import (user_signed_up, user_logged_in,
email_confirmed, password_reset)
from .signals import (user_created_handler, user_logged_in_handler,
email_confirmed_handler, user_password_reset_handler)
# Subclass AbstractUser
class User(AbstractUser):
"""
This is the extended Django user on the web application, so that
we can add additional data and behavior to the base user model.
Each front end django user has a corresponding user entry in the
API backend.
"""
def __unicode__(self):
return self.username
# Hook up signals to django-allauth
user_signed_up.connect(user_created_handler)
email_confirmed.connect(email_confirmed_handler)
user_logged_in.connect(user_logged_in_handler)
password_reset.connect(user_password_reset_handler)
from django.db import models
from allauth.account.forms import SignupForm
from django.contrib.auth import get_user_model
from allauth.account.signals import user_signed_up
class Profile(models.Model):
user = models.OneToOneField(get_user_model(), on_delete=models.CASCADE)
location = models.CharField(max_length=50, blank=True)
interest = models.CharField(max_length=240, blank=True)
about = models.TextField(blank=True)
def __str__(self):
return f"{self.user.username} profile"
User = get_user_model()
def user_signed_up_receiver(request, user, **kwargs):
if user_signed_up:
Profile.objects.create(user=user)
user_signed_up.connect(user_signed_up_receiver, sender=User)
else:
return self.user.username
def stripe_callback(sender, request, user, **kwargs):
user_stripe_account, created = UserStripe.objects.get_or_create(user=user)
if created:
print "created for {}".format(user.username)
if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '':
new_stripe_id = stripe.Customer.create(email=user.email)
user_stripe_account.stripe_id = new_stripe_id['id']
user_stripe_account.save()
user_signed_up.connect(stripe_callback)
user_logged_in.connect(stripe_callback)
class UserDefaultAddress(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL)
shipping = models.ForeignKey("UserAddress",
null=True,
blank=True,
related_name="user_address_shipping_default")
billing = models.ForeignKey("UserAddress",
null=True,
blank=True,
related_name="user_address_billing_default")
def __unicode__(self):
def get_full_name(self):
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def get_short_name(self):
return self.first_name
def email_user(self, subject, message, from_email=None):
send_mail(subject, message, from_email, [self.email])
def get_user_type(self):
if self.is_superuser:
return "superuser"
elif self.groups.filter(name='professors').count():
return "professors"
elif self.groups.filter(name='students').count():
return "students"
return "unidentified"
def is_pilot(self):
return self.groups.filter(name='pilot_course').count() > 0
@staticmethod
def add_default_group(sender, user, **kwargs):
if settings.REGISTRATION_DEFAULT_GROUP_NAME:
user.groups.add(Group.objects.get(name=settings.REGISTRATION_DEFAULT_GROUP_NAME))
user.save()
user_signed_up.connect(TimtecUser.add_default_group, dispatch_uid="TimtecUser.add_default_group")
from django.conf import settings
from django.shortcuts import reverse
from django.core.validators import MaxValueValidator, MinValueValidator
from django.utils.text import slugify
from allauth.account.signals import user_signed_up
from django.contrib.auth import get_user_model
#User Groups
from django.contrib.auth.models import Group
def add_user_to_group(request, user, **kwargs):
user.groups.add(Group.objects.get(name='customers'))
user_signed_up.connect(add_user_to_group, sender=get_user_model())
CATEGORY_CHOICES = (
('A', 'Available'),
('NA', 'Not Available'),
)
LABEL_CHOICES = (
('P', 'primary'),
('S', 'secondary'),
('D', 'danger'),
)
PAYMENTS_CHOICES = (
('S', 'Online Payment'),
('C', 'Cash On Delivier '),
)
"Error setting up invited user - Inviter user not found")
else:
user.userorganization = inviter_user.userorganization
user.is_admin = False
user.is_team_member = True
user.is_organisation_default = False
try:
user.save()
except:
logger.critical("Error updating invited users")
else:
try:
emailAddress = EmailAddress.objects.get(email=user.email)
except:
emailAddress = EmailAddress()
emailAddress.user = user.pk
emailAddress.email = user.email
emailAddress.verified = True
emailAddress.primary = True
try:
emailAddress.save()
except:
logger.critical("Error setting up verified email")
else:
logger.info("Invited users - email already verified.")
user_signed_up.connect(post_user_signed_up_checkinvitation)
email_confirmed.connect(post_email_confirmed)
def __unicode__(self):
if self.stripe_id:
return str(self.stripe_id)
else:
return self.user.username
def stripeCallback(sender,request,user,**kwargs):
'''create a stripe user for just looged in users and assign a stripe id'''
user_stripe_account,created = stripeUser.objects.get_or_create(user=user)
if created:
print ('created for %s'%(user.username))
if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '':
#new customer created using useremail, request made
new_stripe_id = stripe.Customer.create(email=user.email) #from stripe docs-how to create new customer.
#the stripeid is alloted from the JSON response to above request
user_stripe_account.stripe_id = new_stripe_id['id']
user_stripe_account.save()
def dashboardCallback(sender,request,user,**kwargs):
'''create a dashboard for just signed up users'''
userdashboard, is_created = dashboard.objects.get_or_create(user=user)
if is_created:
userdashboard.username = user.username
userdashboard.save()
user_logged_in.connect(stripeCallback)
user_signed_up.connect(dashboardCallback)
user_signed_up.connect(stripeCallback)
def ready(self):
user_signed_up.connect(log_user_signed_up,
dispatch_uid="user_signed_up")
email_confirmed.connect(log_email_confirmed,
dispatch_uid="email_confirmed")
class userStripe(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL)
stripe_id = models.CharField(max_length=200, null=True, blank=True)
def __unicode__(self):
if self.stripe_id:
return str(self.stripe_id)
else:
return self.user.username
def clbk(sender, request, user, **kwargs):
stripe_ac, created = userStripe.objects.get_or_create(user=user)
if created:
print "created for %s" % (user.username)
if stripe_ac.stripe_id == None or stripe_ac.stripe_id == "":
new_stripe_id = stripe.Customer.create(email=user.email)
stripe_ac.stripe_id = new_stripe_id["id"]
stripe_ac.save()
prof, cr = Profiles.objects.get_or_create(user=user)
if cr:
prof.name = user.username
prof.save()
user_logged_in.connect(clbk)
user_signed_up.connect(clbk)
name += ' '
name += last_name
account.name = name
if social_login.account.provider == 'google':
if 'name' in social_login.account.extra_data:
account.name = social_login.account.extra_data['name']
if 'picture' in social_login.account.extra_data:
account.external_avatar_url = social_login.account.extra_data['picture']
account.save()
# Connect django-allauth Signals
user_signed_up.connect(new_sign_up)
class AccountManager(BaseUserManager):
def create_user(self, email, password=None, **kwargs):
if not email:
raise ValueError('Users must have a valid email address.')
if not kwargs.get('username'):
raise ValueError('Users must have a valid username.')
account = self.model(
email=self.normalize_email(email), username=kwargs.get('username')
)
account.set_password(password)
except:
# whoops, user is gone...
user = None
if user is not None:
self.upsert_user(user)
mongo = MongoConnector()
def update_user_handler(sender, **kwargs):
mongo.upsert_user(kwargs.get('user'))
def update_related_user_handler(sender, **kwargs):
mongo.upsert_related_user(kwargs.get('instance'))
def update_emailrelated_handler(sender, **kwargs):
mongo.upsert_related_user(kwargs.get('email_address'))
def user_delete_handler(sender, **kwargs):
mongo.remove_user(kwargs.get('instance'))
user_signed_up.connect(update_user_handler, dispatch_uid='dd_user_signed_up')
user_logged_in.connect(update_user_handler, dispatch_uid='dd_user_logged_in')
email_changed.connect(update_user_handler, dispatch_uid='dd_email_changed')
email_added.connect(update_user_handler, dispatch_uid='dd_email_added')
email_confirmed.connect(update_emailrelated_handler, dispatch_uid='dd_email_donfirmed')
post_delete.connect(user_delete_handler, sender=User, dispatch_uid='dd_user_delete')
post_delete.connect(update_related_user_handler, sender=EmailAddress, dispatch_uid='dd_email_delete')
post_delete.connect(update_related_user_handler, sender=SocialAccount, dispatch_uid='dd_social_delete')
post_save.connect(update_related_user_handler, sender=SocialAccount, dispatch_uid='dd_social_save')
def ready(self):
user_signed_up.connect(process_upon_user_signed_up, dispatch_uid="process_upon_user_signed_up")
user_logged_in.connect(process_upon_user_logged_in, dispatch_uid="process_upon_user_logged_in")
from allauth.account.signals import user_signed_up
from dd_invitation import admin_views as invitation
def consume_invite_token(sender, **kwargs):
request = kwargs.get('request', None)
user = kwargs.get('user', None)
if request is not None:
token = request.session.get('invitation_token', None)
if token is not None:
request.session['invitation_token'] = None
invitation.consume_token(request, token, extra_user=user)
user_signed_up.connect(consume_invite_token, dispatch_uid='dd_user_signed_up_consume_token')
name += last_name
account.name = name
if social_login.account.provider == 'google':
if 'name' in social_login.account.extra_data:
account.name = social_login.account.extra_data['name']
if 'picture' in social_login.account.extra_data:
account.external_avatar_url = social_login.account.extra_data[
'picture']
account.save()
# Connect django-allauth Signals
user_signed_up.connect(new_sign_up)
class AccountManager(BaseUserManager):
def create_user(self, email, password=None, **kwargs):
if not email:
raise ValueError('Users must have a valid email address.')
if not kwargs.get('username'):
raise ValueError('Users must have a valid username.')
account = self.model(email=self.normalize_email(email),
username=kwargs.get('username'))
account.set_password(password)
account.access_level = 0
get_invitations_adapter().send_mail(
email_template,
self.email,
ctx)
except Exception:
import traceback
traceback.print_exc()
def get_anonymous_user_instance(user_model):
return user_model(pk=-1, username='******')
""" Connect relevant signals to their corresponding handlers. """
user_logged_in.connect(do_login)
user_logged_out.connect(do_logout)
social_account_added.connect(
update_user_email_addresses,
dispatch_uid=str(uuid4()),
weak=False
)
user_signed_up.connect(
notify_admins_new_signup,
dispatch_uid=str(uuid4()),
weak=False
)
signals.post_save.connect(
profile_post_save,
sender=get_user_model()
)
display_name = models.CharField(max_length=100)
is_online = models.BooleanField(default=False)
status = models.CharField(max_length=255, blank=True)
def __str__(self):
return self.display_name
@staticmethod
def create_profile(request, user, **kwargs):
return Profile.objects.create(
user=user,
display_name='{}.{}'.format(
user.first_name, user.last_name).strip('.'),
)
user_signed_up.connect(Profile.create_profile)
class Organization(models.Model):
name = models.CharField(max_length=255)
is_active = models.BooleanField(default=True)
users = models.ManyToManyField(Profile)
def __str__(self):
return self.name
class Room(models.Model):
name = models.CharField(max_length=75)
organization = models.ManyToManyField(Organization, blank=True)
users = models.ManyToManyField(
# - get object or 404, get list or 404, paging
# 과제2 bootstrap 디자인, 템플릿, 확장
# 20190514
# 과제1: Document, Category, Board 모델까지 확장
# Category - board = models.ForeignKey(Board)
# 게시판에서의 category - 질문, 답변, 판매, 구매
# 쇼핑몰에서의 category - 상의, 하의, -> 상위 카테고리 - 하위코테고리
# category에 depth를 어떻게 구현할 것이냐? 고민!
# 과제2: 검색 페이지 구현, Board?, Category?, Document?
# ex) 검색시 programming이라는 이름을 가진 1) 게시판, 2) 카테고리, 3) 게시글
# 과제3: 전화번호부
# 구현 - 이름, 전화번호, 메모 + 검색
from allauth.account.signals import user_signed_up
from allauth.socialaccount.models import SocialAccount
# 과제 : 페이스북으로 소셜 로그인 - heroku 업로드
# 시그널이 발생했을 때 실행 될 함수
def naver_signup(request, user, **kwargs):
social_user = SocialAccount.objects.filter(user=user)
if social_user.exists():
user.last_name = social_user[0].extra_data['name']
user.save()
# 시그널과 해당 함수 connect
# 시그널 연결방법 2가지 receiver 쓰는 방법, connect 쓰는 방법
user_signed_up.connect(naver_signup)
# user = kwargs["user"]
# id_stripe, created = UserStripe.objects.get_or_create(user = user)
# if created:
# print ("created stripe id for %s"%(user.username))
# user_profile, is_created = Profile.objects.get_or_create(user = user)
# if is_created:
# user_profile.name = user.username
# user_profile.save()
def stripe_call_back (sender, **kwargs):
user = kwargs["user"]
user_stripe_acc, created = UserStripe.objects.get_or_create(user=user)
if created:
print ("created stripe id for %s" %(user.username))
if user_stripe_acc.stripe_id is None or user_stripe_acc.stripe_id == '':
new_stripe_id = stripe.Customer.create(email=user.email)
user_stripe_acc.stripe_id = new_stripe_id['id']
user_stripe_acc.save()
def profile_call_back (sender, **kwargs):
user = kwargs["user"]
user_profile, is_created = Profile.objects.get_or_create(user=user)
if is_created:
user_profile.name = user.username
user_profile.save()
user_logged_in.connect(stripe_call_back)
user_signed_up.connect(profile_call_back)
user_signed_up.connect(stripe_call_back)
# user_logged_in.connect(my_callback)
# def __unicode__(self): # if self.stripe_id: # return str(self.stripe_id) # else: # return self.user.username # # # def stripe_callback(sender, request, user, **kwargs): # user_stripe_account, created = UserStripe.objects.get_or_create(user=user) # if created: # print "created for %s" %(user.username) # # if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id == '': # new_stripe_id = stripe.Customer.create(email=user.email) # user_stripe_account.stripe_id = new_stripe_id['id'] # user_stripe_account.save() # # # def profile_callback(sender, request, user, **kwargs): profile, is_created = Profile.objects.get_or_create(user=user) if is_created: profile.name = user.username profile.save() # # # user_logged_in.connect(stripe_callback) # user_signed_up.connect(stripe_callback) user_signed_up.connect(profile_callback) #
################################################################### ################################################################### def profile_create(sender, request, user, *args, **kwargs): try: with transaction.atomic(): profile = Profile(user=user) profile.save() except IntegrityError: user.delete() except: user.delete() user_signed_up.connect(profile_create, dispatch_uid="profile_create") """ def generate_welcome_notification(sender, instance, created, *args, **kwargs): print "##########################################" print "##########################################" print "##########################################" print sender print "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" print instance print "##########################################" print created if created: notification = Notification(profile = None, tittle = WELCOME_HEAD_STR, message = WELCOME_BODY_STR)
def get_short_name(self):
return self.first_name
def email_user(self, subject, message, from_email=None):
send_mail(subject, message, from_email, [self.email])
def get_user_type(self):
if self.is_superuser:
return "superuser"
elif self.groups.filter(name='professors').count():
return "professors"
elif self.groups.filter(name='students').count():
return "students"
return "unidentified"
def is_pilot(self):
return self.groups.filter(name='pilot_course').count() > 0
@staticmethod
def add_default_group(sender, user, **kwargs):
if settings.REGISTRATION_DEFAULT_GROUP_NAME:
user.groups.add(
Group.objects.get(
name=settings.REGISTRATION_DEFAULT_GROUP_NAME))
user.save()
user_signed_up.connect(TimtecUser.add_default_group,
dispatch_uid="TimtecUser.add_default_group")
if hasattr(user, '_wrapped') and hasattr(user, '_setup'):
if user._wrapped.__class__ == object:
user._setup()
user = user._wrapped
if not user.is_staff:
user.is_staff = True
user.save()
try:
profile = Profile.objects.get(user=user)
except Profile.DoesNotExist:
profile = Profile(user=user)
profile.save()
user_signed_up.connect(add_profile)
user_logged_in.connect(add_profile)
# Create your views here.
def get_music_metadata(file):
with open(os.path.join(temp_upload_path,file.name),'wb+') as destination:
for chunk in file.chunks():
destination.write(chunk)
meta = {}
music = eyed3.load(os.path.join(temp_upload_path,file.name))
if music:
if music.tag:
def get_anonymous_user_instance(Profile):
return Profile(pk=-1, username='******')
def profile_post_save(instance, sender, **kwargs):
"""
Make sure the user belongs by default to the anonymous group.
This will make sure that anonymous permissions will be granted to the new users.
"""
from django.contrib.auth.models import Group
anon_group, created = Group.objects.get_or_create(name='anonymous')
instance.groups.add(anon_group)
# do not create email, when user-account signup code is in use
if getattr(instance, '_disable_account_creation', False):
return
""" Connect relevant signals to their corresponding handlers. """
social_account_added.connect(
update_user_email_addresses,
dispatch_uid=str(uuid4()),
weak=False
)
user_signed_up.connect(
notify_admins_new_signup,
dispatch_uid=str(uuid4()),
weak=False
)
signals.post_save.connect(profile_post_save, sender=Profile)
def set_registration_active(self):
from allauth.account.signals import user_signed_up, email_confirmed
user_signed_up.connect(self.set_inactive)
email_confirmed.connect(self.set_active)
if self.stripe_id:
return str(self.stripe_id)
else:
return self.user.username
def StripeCallback(sender,request,user, **kwargs):
# print "Request finished!"
# print kwargs
user_stripe_account,created =userStripe.objects.get_or_create(user=user)
if created:
print "created for %s" %(user.username)
if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id =='':
new_stripe_id = stripe.Customer.create(email=user.email)
user_stripe_account.stripe_id =new_stripe_id['id']
user_stripe_account.save()
def profileCallback(sender,request,user, **kwargs):
userProfile,is_created =profile.objects.get_or_create(user=user)
if is_created:
userProfile.name =user.username
userProfile.save()
# user_logged_in.connect(my_callback)
user_signed_up.connect(profileCallback)
user_signed_up.connect(StripeCallback)
user_logged_in.connect(StripeCallback)
from django.shortcuts import render, HttpResponseRedirect
from django.contrib.auth import login, logout
from django.dispatch import receiver
from allauth.account.signals import user_signed_up, user_logged_in
from accounts.models import User
def signup_handler(sender, user, request, **kwargs):
extra_data = user.socialaccount_set.filter(provider='facebook')[0].extra_data
user.gender = extra_data['gender']
user.name = extra_data['name']
user.email = extra_data['email']
user.save()
def logout(request):
print ("logout")
logout(request)
return HttpResponseRedirect('/')
def login_handler(sender, user, request, **kwargs):
print(sender)
print(user)
print(request)
user_logged_in.connect(login_handler)
user_signed_up.connect(signup_handler)
def get_absolute_url(self):
return reverse('profile-detail', kwargs={'pk': self.pk})
def __str__(self):
return self.user.username
def ProfileCallback(sender, request, user, **kwargs):
userProfile, is_created = Profile.objects.get_or_create(user=user)
if is_created:
userProfile.name = user.username
userProfile.save()
user_signed_up.connect(ProfileCallback)
RoomType = [
('Single', 'Singles Rooms'),
('Double', 'Doubles Rooms'),
('Triple', 'Triples Rooms'),
('Quadruple', 'Quadruples Rooms'),
]
price_none = 0
price_single = 20
price_double = 30
price_triple = 40
price_quadruple = 50
Prices = [
(price_none, '-----'),
author = models.ForeignKey(Author, null=True)
publisher = models.ForeignKey(Publisher, null=True)
series = models.ForeignKey(Series, null=True)
edition = models.CharField(max_length=128, blank=True)
year = models.IntegerField(choices=YEAR_CHOICES, null=True, blank=True)
dropbox_id = models.CharField(max_length=256, unique=True)
dropbox_sharing_link = models.URLField(default="")
tags = TaggableManager()
def __str__(self):
return "{s.title}".format(s=self)
def dropbox_link(self):
if self.dropbox_sharing_link:
return self.dropbox_sharing_link
sharing_link = get_dropbox_sharing_link(self.owner, self.dropbox_id)
self.dropbox_sharing_link = sharing_link
self.save()
return sharing_link
def initial_import(request, user, **kwargs):
from . import tasks
tasks.sync_dropbox.delay(*build_args_for_sync_dropbox(user))
user_signed_up.connect(initial_import)
class clienteStripe(models.Model): user=models.OneToOneField(settings.AUTH_USER_MODEL) stripe_id = models.CharField(max_length=200, null=True, blank=True) def __unicode__(self): pass if self.stripe_id: return self.stripe_id else: return self.usuario.username def stripeCallback(sender,request, user, **kwargs): cuenta_usuario_Stripe, id_creada=clienteStripe.objects.get_or_create(user=user) if id_creada: print "created for %s"%(user.username) if cuenta_usuario_Stripe.stripe_id == None or cuenta_usuario_Stripe.stripe_id=="": new_stripe_id = stripe.Customer.create(email=user.email) cuenta_usuario_Stripe.stripe_id = new_stripe_id['id'] cuenta_usuario_Stripe.save() def clienteCallback(sender,request, user, **kwargs): usuarioCliente, Cliente_creado=cliente.objects.get_or_create(usuario=user) if Cliente_creado: usuarioCliente.nombre= user.username usuarioCliente.save() user_logged_in.connect(stripeCallback) user_signed_up.connect(stripeCallback) user_signed_up.connect(clienteCallback)
text=content)
message = Message.objects.create(user=user,
body=body,
sent_at=body.sent_at)
# Creates a message to everyone involved
signals.post_save.connect(post_create_messages,
sender=Post,
dispatch_uid="post-create-messages")
# Creates a message when an award has been made
signals.post_save.connect(award_create_messages,
sender=Award,
dispatch_uid="award-create-messages")
def disconnect_all():
signals.post_save.disconnect(post_create_messages,
sender=Post,
dispatch_uid="post-create-messages")
signals.post_save.disconnect(award_create_messages,
sender=Award,
dispatch_uid="award-create-messages")
# django-allauth sends a signal when a new user is created using a social provider or a new social
# provider is connected to an existing user.
user_signed_up.connect(hook_social_account_added)
social_account_added.connect(hook_social_account_added)
award = instance
if created:
# The user sending the notifications.
user = award.user
# Generate the message from the template.
content = html.render(name=AWARD_CREATED_HTML_TEMPLATE, award=award, user=user)
subject = "Congratulations: you won %s" % award.badge.name
# Create the message body.
body = MessageBody.objects.create(author=user, subject=subject, text=content)
message = Message.objects.create(user=user, body=body, sent_at=body.sent_at)
# Creates a message to everyone involved
signals.post_save.connect(post_create_messages, sender=Post, dispatch_uid="post-create-messages")
# Creates a message when an award has been made
signals.post_save.connect(award_create_messages, sender=Award, dispatch_uid="award-create-messages")
def disconnect_all():
signals.post_save.disconnect(post_create_messages, sender=Post, dispatch_uid="post-create-messages")
signals.post_save.disconnect(award_create_messages, sender=Award, dispatch_uid="award-create-messages")
# django-allauth sends a signal when a new user is created using a social provider or a new social
# provider is connected to an existing user.
user_signed_up.connect(hook_social_account_added)
social_account_added.connect(hook_social_account_added)
if self.passage_data.has_key("name"):
return self.passage_data["name"]
else:
return str(self.date_created)
def get_absolute_url(self):
return reverse('planner-detail', kwargs={'slug': self.hash_key})
def save(self, *args, **kwargs):
"""
Save the field with a unique "hash_key"
"""
if not self.hash_key:
hasher = hashlib.sha1("".join([self.user.username,
datetime.datetime.now().isoformat()]))
self.hash_key = base64.urlsafe_b64encode(hasher.digest())[0:7]
super(Passage, self).save()
"""
Signal Handlers
"""
from allauth.account.signals import user_signed_up
from allauth.socialaccount.signals import social_account_added
import stathat
def signup_signal_callback(sender, **kwargs):
# stathat statistic for new registrations
stathat.ez_count('*****@*****.**', 'Users Registered', 1)
user_signed_up.connect(signup_signal_callback)
social_account_added.connect(signup_signal_callback) # most likely a registration
def __unicode__(self):
if self.stripe_id:
return str(self.stripe_id)
else:
return self.user.username
def stripeCallback(sender, request, user, **kwargs):
user_stripe_account, created = userStripe.objects.get_or_create(user=user)
if created:
print 'created for %s'%(user.username)
if user_stripe_account.stripe_id is None or user_stripe_account.stripe_id =='':
new_stripe_id = stripe.Customer.create(email=user.email)
user_stripe_account.stripe_id = new_stripe_id['id']
user_stripe_account.save()
def profileCallback(sender, request, user, **kwargs):
userProfile, is_created = profile.objects.get_or_create(user=user)
if is_created:
userProfile.name = user.username
userProfile.save()
user_logged_in.connect(stripeCallback)
user_signed_up.connect(profileCallback)
user_signed_up.connect(stripeCallback)
if resp['status'] == '200':
root = ET.fromstring(content)
else:
logger.warning('Did not get 200 back from webgroups for %s. Got % ' % (
socialaccount.user, resp))
return
modules = []
for group in root.findall('group'):
if group.find('type').text == "Module":
dep_code = group.find('department').attrib['code']
name = group.attrib['name']
m = re.match(regex % dep_code, name).group(1)
modules.append(m)
year = extra_data['warwickyearofstudy']
logger.info('User %s: ')
logger.info(' Student: %s' % extra_data['student'])
logger.info(' Staff: %s' % extra_data['staff'])
logger.info(' Modules: %s' % modules)
if extra_data['student'] == 'true':
create_student_profile(user, modules, year)
# if extra_data['staff# '] == 'true':
# LecturerProfile()
user_signed_up.connect(warwick_sign_up)
