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='[email protected]')
     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

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.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)

        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()

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')

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)

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)

        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 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)

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)

        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)

      

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):

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)

        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)

            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)

            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)