def __unicode__(self): return self.user def user_registered_callback(sender, user, request, **kwargs): profile = ExUserProfile(user = user) profile.is_human = bool(request.POST["is_human"]) profile.save() user_registered.connect(user_registered_callback)
def test_signal_sent(self): signal_user = set() def user_registered_signal_handler(sender, request, user, **kwargs): signal_user.add(user) user_registered.connect( user_registered_signal_handler) u = self.b.register(self.req, email='*****@*****.**') self.assertIn(u, signal_user)
def show_profile(request): user_registered.connect(user_registered_callback) user = request.user form = EditProfileForm(initial={'first_name': user.first_name, 'last_name': user.last_name, 'email': user.email}) context = { "form": form } return render(request, 'accounts/profile.html', context)
def activate(): from django.db.models.signals import post_delete from django.db.models.signals import post_save from django.contrib.auth.models import Group from django.contrib.auth.models import User post_save.connect(dispatch_post_save_signal, sender=User) post_save.connect(dispatch_post_save_signal, sender=Group) post_delete.connect(dispatch_delete_signal, sender=User) post_delete.connect(dispatch_delete_signal, sender=Group) try: from registration.signals import user_activated from registration.signals import user_registered user_activated.connect(dispatch_user_activated) user_registered.connect(dispatch_user_registered) except ImportError: pass
class UserProfile(FacebookProfileModel): # user = models.OneToOneField(User) user = models.ForeignKey(User, unique=True) first_name = models.CharField(default='', blank=False, max_length=20) last_name = models.CharField(default='', blank=False, max_length=20) address = models.CharField(default='', blank=True, max_length=60) city = models.CharField(default='', blank=True, max_length=20) zipcode = models.IntegerField(default=85111, blank=False, max_length=5) phone = models.CharField(default='', blank=True, max_length=12) email = models.EmailField(default='', blank=True, max_length=40) has_dog = models.BooleanField(default=False) locked_gate = models.BooleanField(default=False) pest_customer = models.BooleanField(default=False) weed_customer = models.BooleanField(default=False) current_balance = models.DecimalField(default=0.00, blank=True, max_digits=6, decimal_places=2) balance_due_date = models.DateField(blank=True, null=True) next_appointment = models.DateField(blank=True, null=True) public = models.BooleanField(default=False, blank=True) notes = models.TextField(default='', blank=True, max_length=400) # user_profile_placeholder = PlaceholderField('user_profile_placeholder') class Meta: verbose_name = _('user profile') verbose_name_plural = _('user profiles') def __unicode__(self): return (self.user.username) def attrs(self): out = [] for field in self._meta.fields: out.extend([field.name, getattr(self, field.name)]) return (out) def user_registered_callback(sender, user, request, **kwargs): profile = UserProfile(user=user) profile.first_name = request.POST["first_name"] profile.last_name = request.POST["last_name"] profile.email = request.POST["email"] profile.zipcode = int(request.POST["zipcode"]) profile.save() user.first_name = request.POST["first_name"] user.last_name = request.POST["last_name"] user.email = request.POST["email"] user.save() user_registered.connect(user_registered_callback)
class UserProfile(models.Model): user = models.ForeignKey(User, unique=True) full_name = models.CharField(max_length=120,blank=True, null=True) def __unicode__(self): #python 3 __str__ return self.user #dispayed in signup field in admin page def user_registered_callback(sender, user, request, **kwargs): profile = UserProfile(user=user) profile.full_name = request.POST["full_name"] profile.save() user_registered.connect(user_registered_callback) # class Contact(models.Model): # email = models.EmailField() # full_name = models.CharField(max_length=120,blank=True, null=True) # message = models.TextField() # timestamp = models.DateTimeField(auto_now=False, auto_now_add=True) # def __unicode__(self): #python 3 __str__ # return self.email #dispayed in signup field in admin page
return potential suffix = str(uuid.uuid4()).split('-')[0] def activate_user(user, request, **kwargs): user.is_active = True user.save() user = authenticate(username=request.POST['username'], password=request.POST['password1']) login(request, user) def get_lexers_list(): lexers = list(get_all_lexers()) for l in lexers: if l[0] == 'ANTLR With Java Target': lexers.remove(l) lexers.append(( 'Markdown', ('markdown', ), )) lexers = sorted(lexers) return lexers user_registered.connect(activate_user)
class TeacherProfile(UserProfile): teacher_code = models.CharField(max_length=32) class TeacherProfileAttributes(models.Model): teacher = models.OneToOneField(TeacherProfile) bio = models.CharField(null=True, verbose_name="Bio", max_length=1024) linkedIn_url = models.CharField(null=True, verbose_name="LinkedIn",max_length=32) twitter_handle = models.CharField(null=True, verbose_name="Twitter", max_length=32) college = models.CharField(null=True, verbose_name="College", max_length=128) gradschool = models.CharField(null=True, verbose_name="Grad School", max_length=128) major = models.CharField(null=True, verbose_name="Major", max_length=128) skills = models.CharField(null=True, verbose_name="Skills", max_length=128) expertise = models.CharField(null=True, verbose_name="Expertise", max_length=128) class TeacherRating(Rating): teacher = models.ForeignKey('TeacherProfile') class StudentProfile(UserProfile): dummy = models.CharField(max_length=32) class StudentProfileAttributes(models.Model): student = models.OneToOneField(StudentProfile) bio = models.CharField(null=True, verbose_name="Bio", max_length=1024) from registration.signals import user_registered user_registered.connect(extra_methods.registerUserProfile)
null=True, blank=True) date_of_birth = models.DateField(_('YYYY-MM-DD'), null=True, blank=True) website = models.URLField(_('website'), null=True, blank=True) feedback = models.BooleanField(_('give feedback'), default=False) comment = models.BooleanField(_('show comments'), default=True) role = models.CharField(max_length=2, choices=ROLE_CHOICES, blank=True, null=True, default='st') def __unicode__(self): return _("%s") % self.user.username def is_authenticated(self): return self.user.is_authenticated() class Meta: app_label = "userprofile" verbose_name = "user profile" verbose_name_plural = "user profiles" def user_profile_callback(sender, user, request, **kwargs): profile = UserProfile(user=user) profile.save() user_registered.connect(user_profile_callback)
from django.contrib.auth.models import Group from registration.signals import user_registered from editor.models import UserRegionalInfo def create_userregionalinfo(sender, user, request, **kwarg): group, created = Group.objects.get_or_create(name='Reporters') user.groups.add(group) UserRegionalInfo.objects.create( user=user, phone=request.POST.get('phone', ''), information=request.POST.get('information', ''), ) user_registered.connect(create_userregionalinfo)
from django.db import models from django.contrib.auth.models import Group, User from registration.signals import user_registered def get_upload_path(instance, filename): import os ext = os.path.splitext(filename)[1] ext = ext.lower() file_path = '{username}/profile_image/{name}.{ext}'.format( username=instance.user.username,name=filename, ext=ext) return file_path def user_registered_callback(sender, user, request, **kwargs): g = Group.objects.get(name='tripper') g.user_set.add(user) user_registered.connect(user_registered_callback) class UserProfile(models.Model): user = models.OneToOneField(User, related_name="profile") picture = models.ImageField(upload_to=get_upload_path, blank=True) # Override the __unicode__() method to return out something meaningful! #def __str__(self): #return self.picture
from django.contrib.auth.models import User from django.db import models from registration.signals import user_registered class UserProfile(models.Model): SEX_CHOICES = (('F', 'Female'), ('M', 'Male')) user = models.OneToOneField(User) sex = models.CharField(max_length=1, choices=SEX_CHOICES, blank=True, null=True) dob = models.DateField('Date of Birth', blank=True, null=True) picture = models.ImageField('Profile Picture', upload_to='profile_picture', blank=True) def is_worker(self): return hasattr(self, 'workerprofile') class WorkerProfile(UserProfile): deposit = models.DecimalField(decimal_places=2, max_digits=9, default=0) def create_user_profile(sender, user, request, **kwargs): # If they are applying to be a worker, create the correct profile worker = request.POST.get('worker') if worker: WorkerProfile.objects.create(user=user) else: UserProfile.objects.create(user=user) user_registered.connect(create_user_profile)
from registration.signals import user_registered, user_activated from registration.models import RegistrationProfile from researcher_UI.models import * from django.contrib.auth import login, authenticate from django.contrib.sites.models import Site def save_researcher_profile_receiver(sender, user, profile, request, **kwargs): researcher_profile, created = researcher.objects.get_or_create( user=profile.user) profile.user.first_name = profile.supplement.first_name profile.user.last_name = profile.supplement.last_name researcher_profile.institution = profile.supplement.institution researcher_profile.position = profile.supplement.position profile.user.save() researcher_profile.save() def activate_user_profile_receiver(sender, user, request, **kwargs): if not user.is_active: user.is_active = True user.backend = 'django.contrib.auth.backends.ModelBackend' user.save() login(request, user) user_registered.connect(save_researcher_profile_receiver) user_activated.connect(activate_user_profile_receiver)
subject = "".join(subject.splitlines()) message = render_to_string( settings.REGISTRATION_NOTIFICATION_EMAIL_TEMPLATE_NAME, context) recipients = [] if settings.REGISTRATION_NOTIFICATION_ADMINS: for userinfo in settings.ADMINS: recipients.append(userinfo[1]) if settings.REGISTRATION_NOTIFICATION_MANAGERS: for userinfo in settings.MANAGERS: recipients.append(userinfo[1]) if settings.REGISTRATION_NOTIFICATION_RECIPIENTS: method_or_iterable = settings.REGISTRATION_NOTIFICATION_RECIPIENTS if callable(method_or_iterable): recipients.extend(method_or_iterable()) elif isinstance(method_or_iterable, (list, tuple)): recipients.extend(method_or_iterable) else: raise ImproperlyConfigured( ('``REGISTRATION_NOTIFICATION_RECIPIENTS`` must ' 'be a list of recipients or function which return ' 'a list of recipients (Currently the value was "%s")') % method_or_iterable) # remove duplications recipients = frozenset(recipients) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, recipients) user_registered.connect(send_notification_email_reciver)
def ready(self): user_registered.connect(record_survey)
_('is public'), help_text=_('Profile is visible for others.')) avatar = StdImageField(_('avatar'), upload_to=avatar_upload, blank=True, size=(settings.AVATAR_SIZE, settings.AVATAR_SIZE, True), thumbnail_size=(settings.AVATAR_THUMBNAIL_SIZE, settings.AVATAR_THUMBNAIL_SIZE, True)) def __unicode__(self): return 'Profile for %s' % self.user.username @property def age(self): d = datetime.date.today() if self.birth_date: return (d.year - self.birth_date.year) \ - int((d.month, d.day) \ < (self.birth_date.month, self.birth_date.day)) else: return None @models.permalink def get_absolute_url(self): return ('profile-detail', (), {'username': self.user.username}) user_registered.connect(UserProfile.objects.profile_callback)
class UserProfile(FacebookProfileModel): # user = models.OneToOneField(User) user = models.ForeignKey(User, unique=True) first_name = models.CharField(default='', blank=False, max_length=20) last_name = models.CharField(default='', blank=False, max_length=20) address = models.CharField(default='', blank=True, max_length=60) city = models.CharField(default='', blank=True, max_length=20) zipcode = models.IntegerField(default=85111, blank=False, max_length=5) phone = models.CharField(default='', blank=True, max_length=12) email = models.EmailField(default='', blank=True, max_length=40) # next_appointment = models.DateTimeField(auto_now_add=True,blank=True) # balance = models.DecimalField(default=0.0,blank=True,max_digits=6,decimal_places=2) # dog = models.BooleanField(default=False,blank=True) web_url = models.URLField(blank=True, null=True) NONE = 'None' BASIC = 'Basic' PREMIUM = 'Premium' support_plan_choices = ((NONE, 'None'), (BASIC, 'Basic'), (PREMIUM, 'Premium')) support_plan = models.CharField(default=NONE, choices=support_plan_choices, max_length=7) current_balance = models.DecimalField(default=0.00, blank=True, max_digits=6, decimal_places=2) balance_due_date = models.DateField(blank=True, null=True) public = models.BooleanField(default=False, blank=True) notes = models.TextField(default='', blank=True, max_length=200) # user_profile_placeholder = PlaceholderField('user_profile_placeholder') class Meta: verbose_name = _('user profile') verbose_name_plural = _('user profiles') def __unicode__(self): return (self.user.username) def attrs(self): out = [] for field in self._meta.fields: out.extend([field.name, getattr(self, field.name)]) return (out) def user_registered_callback(sender, user, request, **kwargs): profile = UserProfile(user=user) profile.first_name = request.POST["first_name"] profile.last_name = request.POST["last_name"] profile.email = request.POST["email"] if request.POST["business_zipcode"] == '': pass else: profile.zipcode = int(request.POST["business_zipcode"]) profile.save() user.first_name = request.POST["first_name"] user.last_name = request.POST["last_name"] user.email = request.POST["email"] user.save() user_registered.connect(user_registered_callback)
user_profile.opportunities_to_teach = form.data['opportunities_to_teach'] user_profile.possible_to_teach = form.data['possible_to_teach'] user_profile.ethnicity = form.data['ethnicity'] user_profile.race = form.data['race'] user_profile.age = form.data['age'] user_profile.highest_degree = form.data['highest_degree'] user_profile.consented = form.data['consented'] user_profile.state = u','.join(request.POST.getlist('state')) user_profile.work_description = \ u','.join(request.POST.getlist('work_description')) user_profile.save() user_registered.connect(update_user_profile) class LoggedInMixinSuperuser(object): @method_decorator(user_passes_test(lambda u: u.is_superuser)) def dispatch(self, *args, **kwargs): return super(LoggedInMixinSuperuser, self).dispatch(*args, **kwargs) class ReportView(LoggedInMixinSuperuser, View): def get(self, request): report = TeachDentistryReport() # setup zip file for the key & value file response = HttpResponse(content_type='application/zip')
contact, _ = EmailContact.objects.get_or_create(email=email, user=user) contact.confirm() user_activated.connect(confirm_email_contact) def process_deferrals(sender, contact, **kwargs): if not contact.confirmed: return False if not contact.user.is_active: return False deferrals = DeferredMessage.objects.filter(contact=contact) for deferral in deferrals: message = deferral.message.encode("utf-8") msg = email.message_from_string(message) gateway.process(msg) deferral.delete() contact_confirmed.connect(process_deferrals) def log_in_user(sender, user, request, **kwargs): user_with_backend = authenticate(username=user.username, password=request.POST['password1']) login(request, user_with_backend) user_registered.connect(log_in_user)
from django.contrib.auth.models import Permission def user_registered_handler(sender, **kwargs): """signal intercept for user_registered""" request = kwargs['request'] new_user = authenticate(username=request.POST['username'], password=request.POST['password1']) view_permissions = ['view_project', 'view_issuetype', 'view_priority', 'view_status', 'view_milestone', 'view_issue', 'view_comment', 'view_commit', ] add_permissions = ['add_project', 'add_issuetype', 'add_priority', 'add_status', 'add_milestone', 'add_issue', 'add_comment', 'add_commit', ] change_permissions = ['change_project', 'change_issuetype', 'change_priority', 'change_status', 'change_milestone', 'change_issue', 'change_comment', 'change_commit', ] delete_permissions = ['delete_project', 'delete_issuetype', 'delete_priority', 'delete_status', 'delete_milestone', 'delete_issue', 'delete_comment', 'delete_commit', ] for v_perm in list(set().union(view_permissions, add_permissions, change_permissions, delete_permissions)): permission = Permission.objects.get(codename=v_perm) if permission: new_user.user_permissions.add(permission) user_registered.connect(user_registered_handler) admin.site.register(Project) admin.site.register(IssueType) admin.site.register(Priority) admin.site.register(Status) admin.site.register(Milestone) admin.site.register(Issue) admin.site.register(Comment) admin.site.register(Commit)
return User.objects.get(pk=user_id) except User.DoesNotExist: return None AUTO_USERNAME_PREFIX = ":auto:" USERNAME_MAX_LENGTH = User._meta.get_field("username").max_length DIGEST_LENGTH = USERNAME_MAX_LENGTH - len(AUTO_USERNAME_PREFIX) def browserid_create_user(email): """Create and return a new User for a new BrowserID login.""" digest = base64.urlsafe_b64encode(hashlib.sha1(email).digest()) username = AUTO_USERNAME_PREFIX + digest[:DIGEST_LENGTH] user = User.objects.create_user(username=username, email=email) add_new_user_role(user) return user def add_new_user_role(user, **kwargs): role = preferences.CorePreferences.default_new_user_role if role is not None: # Have to use groups, not roles, because registration doesn't send our # proxy User with its signal. user.groups.add(role) user_registered.connect(add_new_user_role)
def user_registered_callback(sender, user, request, **kwargs): profile = UserProfile( user = user ) try: profile.gpstc_sailor_id = request.POST["gpstc_sailor_id"] profile.gpstc_team_id = request.POST["gpstc_team_id"] profile.FullName=request.POST["FullName"] profile.NickName=request.POST["NickName"] except: profile.gpstc_sailor_id = 0 profile.gpstc_team_id=0 profile.FullName='' profile.NickName='' profile.save() user_registered.connect(user_registered_callback, dispatch_uid="gps_user_registered_callback") ## ## Models for GPS app ## #class QuerySetManager(models.Manager): # def get_query_set(self): # return self.model.QuerySet(self.model) # def __getattr__(self, attr, *args): # return getattr(self.get_query_set(), attr, *args)
from django.contrib import admin from models import User, UserProfile from django.contrib.auth.signals import user_logged_in from django.db.models import signals # 3rd-party ``registration`` app: connect up the signals import views from registration.signals import user_registered, user_activated class UserProfileAdmin(admin.ModelAdmin): list_display = ('pk', 'user', 'is_validated', 'affiliation', 'country', 'reputation', 'bio', 'uri', 'openid', 'contactable_via_site', 'allow_user_to_email') list_display_links = ('user', ) list_per_page = 1000 ordering = ('user', ) admin.site.register(UserProfile, UserProfileAdmin) # Hook up the signals here. Doing it in models.py results in circular imports. user_registered.connect(views.create_new_account) user_activated.connect(views.account_activation) user_logged_in.connect(views.user_logged_in) # Create a ``UserProfile`` for every user signals.post_save.connect(views.create_new_account, User)
from django.db import models from django.contrib.auth.models import User from registration.signals import user_registered from timezones.fields import TimeZoneField from timezones.utils import localtime_for_timezone, adjust_datetime_to_timezone # Create your models here. class UserProfile(models.Model): user = models.ForeignKey(User, related_name="profiles") timezone = TimeZoneField() def __unicode__(self): return self.user.username @classmethod def create_from_registration(cls, sender, user, request, **kwargs): # Will get here when registration.views.register sends the # user_registered signal. Form class set to CustomRegistrationForm # for view so assumed timezone will be included with request. print request.POST print request.POST["timezone"] UserProfile.objects.create(user=user, timezone=request.POST["timezone"]) user_registered.connect(UserProfile.create_from_registration)
) member = models.BooleanField(default=False) membershipType = models.IntegerField(choices=MEMBERSHIP_TYPES, default=NONE_MTYPE) membershipExpiry = models.DateTimeField(null=True, blank=True) # specific per game customWordwallsStyle = models.CharField(max_length=1000, blank=True) wordwallsSaveListSize = models.IntegerField(default=0) wordwallsMedals = models.TextField(null=True, blank=True) # project-wide defaultLexicon = models.ForeignKey(Lexicon, default=getLexicon) avatarUrl = models.CharField(null=True, blank=True, max_length=512) additional_data = models.TextField(default='{}', blank=True) def __unicode__(self): return "Profile for " + self.user.username def user_registered_handler(sender, user, request, **kwargs): profile = AerolithProfile() profile.user = user profile.save() user_registered.connect(user_registered_handler) # specific tables
class Day(models.Model): goal = models.ForeignKey(Goal) date = models.DateTimeField('date done') def __str__(self): return str(self.date) class Meta: ordering = ['date'] class Credit(models.Model): user = models.ForeignKey(User) credit = models.IntegerField(default=1) def __unicode__(self): return '%s %d' % (self.user.username, self.credit) class Achievement(models.Model): user = models.ForeignKey(User) reason = models.TextField() def __unicode__(self): return '%s' % (self.reason) def add_credit(sender, user, request, **kwargs): Credit.objects.create(user=user, credit=1) user_registered.connect(add_credit)
# def logout_page(request): # logout(request) # return HttpResponseRedirect('/') # Create user profile after receiving activation signal from registration.signals import user_registered def user_registered_profile(sender, user, request, **kwargs): profile = Profile(user_id=user.id) profile.email = user.email profile.save() user_registered.connect(user_registered_profile) def home(request): gigs = Gig.objects.filter(status=True).order_by('create_time') return render(request, 'home.html', {"gigs": gigs}) # gig_list = Gig.objects.filter(status=True) # page = request.GET.get('page', 1) # paginator = Paginator(gig_list, 20) # try:
out = beta_test_items() message_body = "ID: %s" % (out['name']) message_body += "\nHaves:\n" for have in out["haves"]: message_body += "%s" % (have) message_body += "\nNeeds:\n" for have in out["needs"]: message_body += "%s" % (have) instructions = "%s\n%s\n%s" % (message_front, message_body, message_end) message = NotificationMessage(sender=user, notify_type=NotificationMessage.BETA_TEST, contents=instructions) message.send() post_save.connect(create_profile, sender=User, dispatch_uid="users-profilecreation-signal") post_save.connect(create_api_key, sender=User) user_registered.connect(activate_user) user_registered.connect(send_verification_email) class EmailSender: MESSAGES = '*****@*****.**' INVENTORY = '*****@*****.**' REQUESTS = '*****@*****.**' ADMIN = '*****@*****.**' FEEDBACK = '*****@*****.**'
from django.dispatch import receiver from registration.signals import user_registered from cross_founding_platform.cross_founding.forms import BackerRegistrationForm from cross_founding_platform.cross_founding.models import Backer @receiver(user_registered) def backer_registration(sender, user, request, **kwargs): form = BackerRegistrationForm(request.POST) user.first_name = form.data["first_name"] user.last_name = form.data["last_name"] user.save() backer = Backer(user=user) backer.gender = form.data["gender"] backer.location = request.META['REMOTE_ADDR'] backer.dob_at = form.get_dob() backer.twitter_user = form.data['twitter_user'] backer.facebook_user = form.data['facebook_user'] backer.access_token = form.data['access_token']if form.data['access_token'] != '' else None backer.secret_token = form.data['secret_token']if form.data['secret_token'] != '' else None backer.expire_token = form.data['expire_token']if form.data['expire_token'] != '' else None backer.third_party_id = form.data['third_party_id']if form.data['third_party_id'] != '' else None backer.save() user_registered.connect(backer_registration)
from django.db.models import permalink from registration.signals import user_registered from oncallr.notification.models import NOTIFICATION_CHOICES PHONE_STATUSES = ( (0, "Unverified"), (1, "Verified") ) class Profile(models.Model): user = models.OneToOneField(User, related_name='profile', on_delete=models.PROTECT) contact_method = models.PositiveSmallIntegerField(choices=NOTIFICATION_CHOICES, default=0) language_pref = models.CharField(verbose_name='Language Preference', max_length=4, choices=settings.LANGUAGES) # only contains teams that a user is a memeber of, not a leader. teams = models.ManyToManyField(Team, related_name='teams', blank=True, null=True) def __unicode__(self): return self.user.username @permalink def get_absolute_url(self): return ('profile_detail', None, {'username': self.user.username}) def post_registration_profile_creation(sender, **kwargs): """ Create a profile for a user post registration. """ user = kwargs.pop('user') request = kwargs.pop('request') Profile.objects.create(user=user) user_registered.connect(post_registration_profile_creation)
from django.contrib.auth.forms import AuthenticationForm from django.contrib.auth import login from registration.signals import user_registered, user_activated def login_on_registration_or_activation(sender, user, request, **kwargs): user.backend = 'django.contrib.auth.backends.ModelBackend' login(request, user) user_registered.connect(login_on_registration_or_activation) user_activated.connect(login_on_registration_or_activation) AuthenticationForm.base_fields['username'].max_length = 150 AuthenticationForm.base_fields['username'].widget.attrs['maxlength'] = 150 AuthenticationForm.base_fields['username'].validators[0].limit_value = 150 AuthenticationForm.base_fields['username'].label = "Email Address:"
''' try: request = kwargs.get('request') first_name = '' last_name = '' if request is not None: first_name = request.POST.get('first_name','') last_name = request.POST.get('last_name','') city = request.POST.get('city','') zip = request.POST.get('zip','') bike = request.POST.get('bike','') email = request.POST['email'] avatar_hash = hashlib.md5(email.lower()).hexdigest() user = kwargs.get('user') if user is not None: logger.debug('User is good') user.first_name = first_name user.last_name = last_name user.save() profile, created = UserProfile.objects.get_or_create(user=user) profile.city = city profile.zip = zip profile.bike = bike profile.avatar = avatar_hash profile.save() except: logger.error('Failed to save user profile data: %s' % request.POST) user_registered.connect(save_user_names)
key=lambda x: x[0]) article_list = [j[i] for k, g in groups for i, j in enumerate(g)] return article_list, [(tag, topics[tag], value) for tag, value in enumerate(article_tags)] def user_registered_callback(sender, user, request, **kwargs): """ :param user: user_auth model object Callback to create profile when creating a user auth object """ profile = UserProfileRec(user=user) """ initialise profile ratings """ profile_topics = {"twitter_topics": {topics.index(t): 0 for t in topics}, "explicit_topics": {topics.index(t): 0 for t in topics}, "clicked_topics": Counter({topics.index(t): 0 for t in topics}), "shown_topics": Counter({topics.index(t): 0 for t in topics})} profile.profile_topics = base64.b64encode(pickle.dumps(profile_topics)) profile.save() """ connect callback to registration event """ user_registered.connect(user_registered_callback)
notification = Notification() notification.user = instance notification.save() address = Address() address.save(user=instance) profile = UserProfile() profile.user = instance profile.address = address profile.save() today = datetime.date.today() default_state = SUBSCRIPTION_STATE_TRIAL if settings.FREE_SUBSCRIPTION: default_state = SUBSCRIPTION_STATE_FREE subscription = Subscription.objects.create( owner=instance, state=default_state, expiration_date=today + datetime.timedelta(settings.TRIAL_DURATION), transaction_id='TRIAL-%i%i%i-%i' % (today.year, today.month, today.day, instance.id)) def log_registration(sender, user, request, **kwargs): logger = logging.getLogger('aemanager') logger.info('%s <%s> has registered' % (user.username, user.email)) post_save.connect(user_post_save, sender=User) user_registered.connect(log_registration)
from teachercomapp.forms import UserRegistrationForm from django.contrib.auth.models import User from teachercomapp.models import Teacher from registration.signals import user_registered # create teacher takes as kwargs a form input from the registration form, including user info and the twilio info def create_teacher(sender, **kwargs): request = kwargs['request'].POST form = UserRegistrationForm(request) extended_user = Teacher() extended_user.user = User.objects.get(username=request['username']) extended_user.twilio_account_sid = request['twilio_account_sid'] extended_user.twilio_auth_token = request['twilio_auth_token'] extended_user.twilio_number = request['twilio_number'] extended_user.save() print "teacher created" user_registered.connect(create_teacher)
class UserProfile(models.Model): user = models.OneToOneField(User) user_sets = models.ManyToManyField(Sets, blank = True) def __unicode__(self): return unicode(self.user) from registration.signals import user_registered def createUserProfile(sender, user, request, **kwargs): UserProfile.objects.get_or_create(user=user) user_registered.connect(createUserProfile) class KnownKanji(models.Model): #should be a foreign key kanji = models.ManyToManyField(Kanji) date_added = models.DateTimeField(auto_now_add = True) selected_kanji = models.BooleanField(default = False) user_profile = models.ManyToManyField(UserProfile) #im not sure what this is for.... number_of_chosen_words = models.IntegerField(null = True) def __unicode__(self): return unicode(self.kanji) def display_kanji(self):
invites = self.filter(created_for_email__iexact=user.email) for i in invites: # Connect the user to the invites i.created_for_user = user # Handle the responses if i.response == 2: i.project.members.add(user) i.save() class Invite(models.Model): """ A base model for invites """ sha = models.CharField(_('sha'), max_length=40) date = models.DateField(_('date'), auto_now_add=True) response = models.PositiveIntegerField(choices=RESPONSE_CHOICES, default=1) project = models.ForeignKey(Project, related_name='') created_by = models.ForeignKey(User, related_name='send_invites') created_for_user = models.ForeignKey(User, related_name='created_invites', blank=True, null=True) created_for_email = models.EmailField(blank=True, null=True) objects = InviteManager() def __unicode__(self): created_for = self.created_for_user.username if self.created_for_user else self.created_for_email return '%(created_by)s invited %(created_for)s for %(project)s' % {'created_by': self.created_by.username, 'created_for': created_for, 'project': self.project.name} user_registered.connect(Invite.objects.register_signal) oid_associate.connect(Invite.objects.register_signal)
from teachercomapp.forms import UserRegistrationForm from django.contrib.auth.models import User from teachercomapp.models import Teacher from registration.signals import user_registered # create teacher takes as kwargs a form input from the registration form, including user info and the twilio info def create_teacher(sender, **kwargs): request = kwargs['request'].POST form=UserRegistrationForm(request) extended_user = Teacher() extended_user.user = User.objects.get(username=request['username']) extended_user.twilio_account_sid = request['twilio_account_sid'] extended_user.twilio_auth_token = request['twilio_auth_token'] extended_user.twilio_number=request['twilio_number'] extended_user.save() print "teacher created" user_registered.connect(create_teacher)
from django.db import models from django.contrib.auth.models import User from django.db.models.signals import post_save from registration.signals import user_registered class UserProfile(models.Model): user = models.OneToOneField(User) contact = models.CharField(max_length=15, blank=True) address = models.TextField(max_length=250, blank=True) def create_user_profile(sender, instance, created, **kwargs): if created: UserProfile.objects.create(user=instance) post_save.connect(create_user_profile, sender=User) def update_user_profile(sender, user, request, **kwargs): data = request.POST user.first_name = data.get('first_name') user.last_name = data.get('last_name') user.save() user_profile, created = UserProfile.objects.get_or_create(user=user) user_profile.address = data.get('address') user_profile.contact = data.get('contact') user_profile.postal = data.get('postal') user_profile.save() user_registered.connect(update_user_profile)
abstract = True class Hacker(UserProfile): # position in company position = models.CharField(blank=False, null=False, max_length=200) def __unicode__(self): return self.get_name @classmethod def create_hacker(cls, sender, **kwargs): request, instance = kwargs['request'], kwargs['user'] try: position = request.POST['position'] cls(user=instance, position=position).save() except KeyError: #UserProfile(user = instance).save() #Default create just a profile pass @property def get_email(self): return self.user.email @property def get_name(self): return self.user.first_name + ' ' + self.user.last_name user_registered.connect(Hacker.create_hacker)
from django.contrib.auth import login from registration.signals import user_registered from notification import models as notification from actstream.actions import follow from dnstorm.app.models import Invitation def login_on_registration(sender, user, request, **kwargs): """ Logs in the user after registration. """ user.backend = 'django.contrib.auth.backends.ModelBackend' login(request, user) user_registered.connect(login_on_registration) def create_notice_types(app, created_models, verbosity, **kwargs): """ Register notification types for django-notification. """ notification.create_notice_type( 'invitation', _('Invitation received'), _('you have received an invitation to collaborate in a problem')) notification.create_notice_type( 'problem', _('Problem updated'), _('a problem you\'re contributing was updated')) signals.post_syncdb.connect(create_notice_types, sender=notification)
if value: potential = "-".join([base, str(suffix)]) else: potential = str(suffix) if not model.objects.filter(**{slugfield: potential}).count(): return potential suffix = str(uuid.uuid4()).split("-")[0] def activate_user(user, request, **kwargs): user = authenticate( username=request.POST["username"], password=request.POST["password1"] ) login(request, user) def get_lexers_list(): lexers = list(get_all_lexers()) for l in lexers: if l[0] == "ANTLR With Java Target": lexers.remove(l) lexers.append(("Markdown", ("markdown",))) lexers = sorted(lexers) return lexers user_registered.connect(activate_user)
return data class LogoutView(View): def get(self, request): django.contrib.auth.logout(request) messages.add_message( request, messages.SUCCESS, u"Atslēgšanās veiksmīga") return redirect('index') class LoginView(View): def post(self, request): form = LoginForm(request.POST) if form.is_valid(): user = django.contrib.auth.authenticate(**form.cleaned_data) if user: django.contrib.auth.login(request, user) return redirect('list_parcels') messages.add_message( request, messages.ERROR, u"E-pasts vai parole nepareiza") return redirect("registration_register") def post_register(sender, **kwargs): messages.add_message( kwargs['request'], messages.SUCCESS, u"Reģistrācija veiksmīga") user_registered.connect(post_register)
from registration.signals import user_registered from main.models import Profile def create_profile(user, **kwargs): Profile.objects.create(user=user) user_registered.connect(create_profile, dispatch_uid='main.signals.create_profile')
def unset_cookie(sender, request, user, **kwargs): request.delete_cookie("__ac") user_logged_out.connect(unset_cookie) def confirm_email_contact(sender, user, **kwargs): if not user.is_active: return False email = user.email contact, _ = EmailContact.objects.get_or_create(email=email, user=user) contact.confirm() user_activated.connect(confirm_email_contact) def process_deferrals(sender, contact, **kwargs): if not contact.confirmed: return False if not contact.user.is_active: return False deferrals = DeferredMessage.objects.filter(contact=contact) for deferral in deferrals: message = deferral.message.encode("utf-8") msg = email.message_from_string(message) gateway.process(msg) deferral.delete() contact_confirmed.connect(process_deferrals) def log_in_user(sender, user, request, **kwargs): user_with_backend = authenticate(username=user.username, password=request.POST['password1']) login(request, user_with_backend) user_registered.connect(log_in_user)
public_group = ExtendedGroup.objects.public_group() # need to check if Public group exists to avoid errors when creating # user accounts (like superuser and AnonymousUser) before the group # is created by init_refinery command if public_group: instance.groups.add(public_group) def create_user_profile_registered(sender, user, request, **kwargs): UserProfile.objects.get_or_create(user=user) logger.info('user profile for user %s has been created after registration %s' % ( user, datetime.now())) mail_admins('New User Registered', 'User %s registered at %s' % (user, datetime.now())) logger.info('email has been sent to admins informing of registration of user %s' % user) user_registered.connect(create_user_profile_registered, dispatch_uid="registered") def register_handler(request, sender, user, **kwargs): messages.success(request, 'Thank you! Your account has been activated.') user_activated.connect(register_handler, dispatch_uid='activated') # check if user has a catch all project and create one if not def create_catch_all_project( sender, user, request, **kwargs ): if user.get_profile().catch_all_project is None: project = Project.objects.create( name="Catch-All Project", is_catch_all=True ) project.set_owner( user ) user.get_profile().catch_all_project = project user.get_profile().save()
if mc is not None: self.mc = mc else: mc = MailChimp(settings.MAILCHIMP_KEY) threading.Thread.__init__(self) def run(self): # The actual code we want to run in the tread print 'username ', self.user.username try: lists = self.mc.lists() mc.listSubscribe( id=lists[0]['id'], email_address=self.user.email, merge_vars={'FNAME': self.user.username}, double_optin=False ) except MailChimpError, e: print e.msg logger.error(e.msg) # Signal which starts the subscribe thread def add_to_mailinglist(sender, user, request, **kwargs): SubscribeEmailThread(user, mc).start() # Create your models here. user_registered.connect(add_to_mailinglist)
class UserProfile(models.Model): # user = models.ForeignKey(User, unique=True) user = models.OneToOneField(settings.AUTH_USER_MODEL, primary_key=True) address = models.CharField(max_length=150, null=True, blank=True) locality = models.CharField(max_length=30, null=True, blank=True) phone_number = models.PositiveIntegerField(null=True, blank=True) description = models.CharField(max_length=150, null=True, blank=True) avatar = models.FileField(upload_to="profile_pic", null=True, blank=True) def assure_user_profile_exists(pk): """ This might not be working. To be judged later """ user = User.objects.get(pk=pk) try: # fails if it doesn't exist userprofile = user.userprofile except UserProfile.DoesNotExist, e: userprofile = UserProfile(user=user) userprofile.save() return def create_user_profile(**kwargs): UserProfile.objects.get_or_create(user=kwargs['user']) user_registered.connect(create_user_profile)
try: user_type = request.POST['usertype'].lower() if user_type == "teacher": #user .lower for case insensitive comparison Teacher(user=instance).save() elif user_type == "student": Student(user=instance).save() else: Profile(user=instance).save( ) #Default create - might want to raise error instead except KeyError: Profile(user=instance).save() #Default create just a profile # This callback is called by a registration signal. # XXX move this function to a meaningful file. def register_with_profile(sender, user, request, **kwargs): profile = Profile(user=user) profile.is_human = bool(request.POST["is_human"]) profile.save() # This callback is called by a registration signal. # XXX move this function to a meaningful file. def register_with_student_profile(sender, user, request, **kwargs): profile = Student(user=user) profile.save() # Now a registered user is always a student. user_registered.connect(register_with_student_profile)
from django.db import models from registration.signals import user_registered class Player(models.Model): user = models.OneToOneField('auth.User') games_played = models.IntegerField(default=0) wins = models.IntegerField(default=0) losses = models.IntegerField(default=0) def __unicode__(self): return self.user.username def create_player(sender, user, request, **kwargs): player = Player() player.user = user player.save() user_registered.connect(create_player)
context) subject = "".join(subject.splitlines()) message = render_to_string( settings.REGISTRATION_NOTIFICATION_EMAIL_TEMPLATE_NAME, context) recipients = [] if settings.REGISTRATION_NOTIFICATION_ADMINS: for userinfo in settings.ADMINS: recipients.append(userinfo[1]) if settings.REGISTRATION_NOTIFICATION_MANAGERS: for userinfo in settings.MANAGERS: recipients.append(userinfo[1]) if settings.REGISTRATION_NOTIFICATION_RECIPIENTS: method_or_iterable = settings.REGISTRATION_NOTIFICATION_RECIPIENTS if callable(method_or_iterable): recipients.extend(method_or_iterable()) elif isinstance(method_or_iterable, (list, tuple)): recipients.extend(method_or_iterable) else: raise ImproperlyConfigured(( '``REGISTRATION_NOTIFICATION_RECIPIENTS`` must ' 'be a list of recipients or function which return ' 'a list of recipients (Currently the value was "%s")' ) % method_or_iterable) # remove duplications recipients = frozenset(recipients) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, recipients) user_registered.connect(send_notification_email_reciver)
from RIGS.models import Profile from RIGS.forms import ProfileRegistrationFormUniqueEmail from registration.signals import user_registered def user_created(sender, user, request, **kwargs): form = ProfileRegistrationFormUniqueEmail(request.POST) user.first_name = form.data['first_name'] user.last_name = form.data['last_name'] user.initials = form.data['initials'] # user.phone = form.data['phone'] user.save() user_registered.connect(user_created)
class RegistrationViewUniqueEmail(RegistrationView): form_class = RegistrationFormUniqueEmail def get_success_url(self, request, user): return '/app/' def create_index_page(sender, user, request, **kwargs): page = Page.objects.create(title='Index', page_number=1, user=user) def index(request): context = RequestContext(request) return render_to_response('index.html', {}, context) @login_required def start_app(request): context = RequestContext(request) return render_to_response('app.html', {}, context) @login_required def user_logout(request): logout(request) return HttpResponseRedirect('index') # When user is registered, create index page for him user_registered.connect(create_index_page)
def asegurar_existencia_perfil_user(pk): usuario = Empleado.objects.get(pk=pk) try: userprofile = usuario.userprofile except UserProfile.DoesNotExist, e: userprofile = UserProfile(user=usuario) userprofile.save() return userprofile def crea_perfil_user(**kwargs): UserProfile.objects.get_or_create(user=kwargs['usuario']) user_registered.connect(crea_perfil_user) @login_required def EditUser(request, slug=None): """ Editar usuario de forma simple. """ user = request.user if request.method == 'POST': form = UserChangeForm(request.POST, instance=user) if form.is_valid(): #Actualizar el objeto user = form.save() messages.success(request, 'Usuario actualizado exitosamente.',
extra_taxes = float(overrun) * float(tax_rate) / 100 return extra_taxes def user_post_save(sender, instance, created, **kwargs): if created and not kwargs.get("raw", False): address = Address() address.save(user=instance) profile = UserProfile() profile.user = instance profile.address = address profile.save() today = datetime.date.today() subscription = Subscription.objects.create( owner=instance, state=SUBSCRIPTION_STATE_TRIAL, expiration_date=today + datetime.timedelta(settings.TRIAL_DURATION), transaction_id="TRIAL-%i%i%i-%i" % (today.year, today.month, today.day, instance.id), ) def log_registration(sender, user, request, **kwargs): logger = logging.getLogger("aemanager") logger.info("%s <%s> has registered" % (user.username, user.email)) post_save.connect(user_post_save, sender=User) user_registered.connect(log_registration)
user.firstname = participant.name participant.email_id = user.email participant.phone_no = form.data["phone_no"] if int(form.data["college"]) == -1: if form.data["add_your_college"] is not None: new_college = College(name=form.data["add_your_college"]) new_college.save() participant.college = new_college else: raise Exception("No College name specified") else: participant.college = College.objects.get(pk=form.data["college"]) participant.roll_no = form.data["rollno"] participant.save() for e in form.data.getlist("events"): participant.events.add(e) def user_verification_updated(sender, user, request, **kwargs): participant = Participant.objects.filter(user__user=user) if participant is not None and len(participant) == 1: participant = participant[0] participant.email_verified = "Yes" participant.save() from registration.signals import user_registered, user_activated user_registered.connect(user_created) user_activated.connect(user_verification_updated)
from django.contrib.auth.models import User, Group from registration.signals import user_registered from editor.models import UserRegionalInfo def create_userregionalinfo(sender, user, request, **kwarg): group, created = Group.objects.get_or_create(name='Reporters') user.groups.add(group) UserRegionalInfo.objects.create( user=user, phone=request.POST.get('phone', ''), information=request.POST.get('information', ''), ) user_registered.connect(create_userregionalinfo)