def moderate_list(request, backend='default', template_name='registration/registration_moderate_list.html'):
    backend = get_backend(backend)
    profiles = backend.get_unmoderated_profiles(request)

    return render(request, template_name, {
        'profiles': profiles,
    })

def accept_email_invite(request, activation_key):
    inv = get_object_or_404 (Invitation, reg_activation_key=activation_key)
    logging.debug("BBM: accept_email_invite view found invite %s." % str(inv))
    
    if request.method == 'POST':
        pw_form = EmailInviteAcceptForm(request.POST)
        if pw_form.is_valid():
            from registration.backends import get_backend
            reg_backend = get_backend(settings.REGISTRATION_BACKEND)
            u = reg_backend.activate(request, activation_key)
            if not u:
                logging.debug('BBM was unable to activate user with activation key %s' % (activation_key))
                messages.error(request, 'Sorry we were unable to activate your user, please try again and contact us if the problem persists')
                return HttpResponseRedirect(reverse('home'))
            else:
                logging.debug('BBM attempting to set password to %s for user %s' % (pw_form.data['password1'], u.username))
                u.set_password(pw_form.data['password1'])
                u.save()
                #authenticate the user and log them in
                auth_user = authenticate(username=u.email, password=pw_form.data['password1'])
                if auth_user is not None:
                    logging.debug('BBM: new invited user %s authenticated' % auth_user.username)
                    #accept invite
                    inv.accept_invitation()
                    login(request, auth_user)
                    messages.info(request, "Thank you %s, your account has been activated and invitation accepted" % auth_user.first_name)
                    return HttpResponseRedirect(reverse('welcome'))
                else:
                    messages.error(request, "Your username and/or password were not recognised, please try again.")
    else:
        pw_form=EmailInviteAcceptForm()
        
    return render_to_response('groupmanager/accept_email_invite.html', {'invite': inv, 'pw_form': pw_form}, context_instance=RequestContext(request))

    def create(self, request, **kwargs):
        #print "@ create account"
        self.method_check(request, allowed=['post'])
        
        backend = get_backend('registration.backends.default.DefaultBackend')
        postData = simplejson.loads(request.raw_post_data)

        args = {'username':postData['username'],
                'email' : postData['email'],
                'password1' : postData['password']}
        
        if User.objects.filter(email=postData['email']).count() > 0:
            return self.create_response(request,{
                    'status': SYSTEM_ERROR,
                    'error': 'duplicate email'})
        
        #print "post data"
        #print args
        #print "trying to create account"
        newUser = backend.register(request,**args)
        
        #print "user created"
        if newUser:
            return self.create_response(request,{'status': OK,
                'message': 'Please check your email !!'})

        else:
            return self.create_response(request,{'status': SYSTEM_ERROR,
                                    'error': 'Something is wrong >:/ '})

def registerStudent(request, backend, success_url=None, form_class=None,
             disallowed_url='registration_disallowed',
             template_name='registration/registration_form.html',
             extra_context=None):
    backend = get_backend(backend)
    if not backend.registration_allowed(request):
        return redirect(disallowed_url)
    if form_class is None:
        form_class = backend.get_form_class(request)
    if request.method == 'POST':
        form = form_class(data=request.POST, files=request.FILES)
        if form.is_valid():
            new_user = backend.register(request, **form.cleaned_data)
            print new_user.first_name
            if success_url is None:
                to, args, kwargs = backend.post_registration_redirect(request, new_user)
                return redirect(to, *args, **kwargs)
            else:
                return redirect(success_url)
    else:
        form = form_class()
    
    if extra_context is None:
        extra_context = {}
    context = RequestContext(request)
    for key, value in extra_context.items():
        context[key] = callable(value) and value() or value

    return render_to_response(template_name,
                              {'form': form},
                              context_instance=context)

def setup_and_activate(request, activation_key, backend,
                       form_class=UserCreationForm,
                       template_name='registration/setup_new_user.html',
                       fail_template_name='registration/activate.html',
                       success_url=None):

    backend = get_backend(backend)
    profile = get_object_or_404(RegistrationProfile, activation_key=activation_key)
    if not backend.can_activate(activation_key):
        return render_to_response(fail_template_name,
                                  context_instance=RequestContext(request))

    if request.method == 'POST':
        form = form_class(request.POST, request.FILES, instance=profile.user)
        if form.is_valid():
            form.save()
            account = backend.activate(request, activation_key)
            if success_url:
                return redirect(success_url)
            to, args, kwargs = backend.post_activation_redirect(request, account)
            return redirect(to, *args, **kwargs)
    else:
        # do not prepopulate form with generated user data
        form = form_class()

    return render_to_response(template_name, {'form': form},
                              context_instance=RequestContext(request))

def send_post_notification_email(post, event, request):
    """
    Send blog post events notification email.
    """
    
    # get the current site
    if Site._meta.installed:
        site = Site.objects.get_current()
    else:
        site = RequestSite(request)

    subject = render_to_string(POST_EVENTS[event]['subject_template'], {
        'site': site,
        'post': post,
    })

    # no newlines
    subject = ''.join(subject.splitlines())

    message = render_to_string(POST_EVENTS[event]['email_template'], {
        'site': site,
        'post': post,
    })

    if POST_EVENTS[event]['receiver'] == 'moderators':
        backend = get_backend('default')
        moderators = (x[1] for x in backend.get_moderators(request))
        send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, moderators)
    if POST_EVENTS[event]['receiver'] == 'author':
        send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, (post.author.email,))

def register(request, backend, success_url=None, form_class=None,
             disallowed_url='registration_disallowed',
             template_name='registration/registration_form.html',
             extra_context=None):

    backend = get_backend(backend)
    if not backend.registration_allowed(request):
        return redirect(disallowed_url)
    if form_class is None:
        form_class = backend.get_form_class(request)

    if request.method == 'POST':
        data = request.POST.copy() # so we can manipulate data
        form = form_class(data, files=request.FILES)
        if form.is_valid():
            # random username
            form.cleaned_data['username'] = ''.join([choice(letters) for i in xrange(30)])
            new_user = backend.register(request, **form.cleaned_data)
            if success_url is None:
                to, args, kwargs = backend.post_registration_redirect(request, new_user)
                return redirect(to, *args, **kwargs)
            else:
                return redirect(success_url)
    else:
        form = form_class()

    if extra_context is None:
        extra_context = {}
    context = RequestContext(request)
    for key, value in extra_context.items():
        context[key] = callable(value) and value() or value

    return render_to_response(template_name,
                              {'form': form},
                              context_instance=context)

    def test_get_backend(self):
        """
        Verify that ``get_backend()`` returns the correct value when
        passed a valid backend.

        """
        self.failUnless(isinstance(get_backend("registration.backends.default.DefaultBackend"), DefaultBackend))

def _register_user(request, facebook, profile_callback=None):
    """
    Creates a new user and authenticates
    The registration form handles the registration and validation
    Other data on the user profile is updates afterwards
    """
    if not facebook.is_authenticated():
        raise ValueError("Facebook needs to be authenticated for connect flows")

    from registration.forms import RegistrationFormUniqueEmail

    new_reg_module = True
    try:
        from registration.backends import get_backend
    except ImportError:
        new_reg_module = False

    form_class = RegistrationFormUniqueEmail
    facebook_data = facebook.facebook_registration_data()

    data = request.POST.copy()
    for k, v in facebook_data.items():
        if not data.get(k):
            data[k] = v

    if request.REQUEST.get("force_registration_hard"):
        data["email"] = data["email"].replace("@", "+%[email protected]" % randint(0, 100000))

    form = form_class(data=data, files=request.FILES, initial={"ip": request.META["REMOTE_ADDR"]})

    if not form.is_valid():
        error = facebook_exceptions.IncompleteProfileError(
            "Facebook data %s " "gave error %s" % (facebook_data, form.errors)
        )
        error.form = form
        raise error

    if new_reg_module:
        # support for the newer implementation
        try:
            from django.conf import settings

            backend = get_backend(settings.REGISTRATION_BACKEND)
        except:
            raise ValueError("Cannot get django-registration backend from " "settings.REGISTRATION_BACKEND")
        new_user = backend.register(request, **form.cleaned_data)
    else:
        new_user = form.save(profile_callback=profile_callback)

    # update some extra data not yet done by the form
    new_user = _update_user(new_user, facebook)

    # IS this the correct way for django 1.3? seems to require the backend
    # attribute for some reason
    new_user.backend = "django_facebook.auth_backends.FacebookBackend"
    auth.login(request, new_user)

    return new_user

def invite_email(request, group_id):
    """
    just a wrapper for emailregiatration backend register view which is a clone of the default registration backend
    but extended to add new users into the appropriate group.
    """
    #TODO: currently supports 1 email invite at a time need to make multiple
    #TODO: capture email text in invite message in when it is editable

    g = get_object_or_404(Group, pk=group_id)

    if request.method == 'POST':
        if g.is_organiser(request.user) or (g.is_member(request.user) and g.is_mem_get_mem) or g.is_open: #check we are the organiser or the group allows others to invite
            next_url=request.POST.get('next', None) #establish where to go next from a next field in the submitted form
            logging.debug("GM: attempting to invite a new email invited member and add to group %s then redirect to %s" % (g.name,next_url))
            user_form = EmailInvitationForm(request.POST)
            #check if this person already exists as a user. If so just invite them.
            if user_form.is_valid():
                try:
                    logging.debug("GM: testing duplicate user by email address %s" % (user_form.data['email']))
                    u = User.objects.filter(email=user_form.data['email'])
                except ObjectDoesNotExist:
                    from registration.backends import get_backend
                    backend = get_backend('emailregistration.backends.registration.InviteEmailRegBackend') #use custom invite backend to send invitation emails
                    #create a new inactive user and send them an activation email
                    u = backend.register(request, **user_form.cleaned_data)
                    messages.info(request, 'Sucessfully invited %s at address %s to join this group.' % (user_form.data['first_name'], user_form.data['email']))
                    #get the activation key from the new inactive user registration profile to put in the invite as a reference
                    from registration.models import RegistrationProfile
                    p = RegistrationProfile.objects.get(user=u)
                    #create the invitation in the db
                    inv = Invitation.objects.create(group_id=g.id, inviter_id=request.user.id, invitee_id=u.id, reg_activation_key=p.activation_key)
                    logging.debug("RM: create invite to group %s from %s to %s" % (g.id, request.user.id, u.id))

                else: #user already exists (by email) so create the invitation in the db no new user no activation key
                    inv = Invitation.objects.create(group_id=g.id, inviter_id=request.user.id, invitee_id=u.id, reg_activation_key='existing user invited')
                    messages.info(request, '%s at address %s is already a user of %s and will receive an invitation to joint this group.' % (u.first_name, u.email, settings.SITE_NAME))
                    logging.debug("RM: create invite to group %s from %s to %s" % (g.id, request.user.id, u.id))
                    #TODO: notify them of the new invite by email

            else: #invalid form re-render the template, show form errors
                logging.debug("GM: Failed to add new email invite user to group %s because posted form was invalid." % (g.name))
                return render_to_response("groupmanager/invite_email_form.html",{'group_id': group_id, 'form':user_form },context_instance=RequestContext(request))

            if settings.AUTO_ACCEPT:  #automatically accept the invite (ie. don't wait for the invitee to do so)
                inv.accept_invitation()

        else: #user doesn't have permission to invite into the group
            logging.error("GM: invite_email_member received request to invite users from user without correct permissions.")
            messages.error(request, 'You do not have permission to invite users to that group. If this problem persists please let us know.')

    else: #its a GET so just render the template
        user_form = EmailInvitationForm()
        return render_to_response("groupmanager/invite_email_form.html",{'group_id': group_id, 'form':user_form },context_instance=RequestContext(request))

    if next_url:
        return HttpResponseRedirect(next_url)
    return HttpResponseRedirect(reverse('group_home', args=[g.id]))

    def get(self, request, backend, *args, **kwargs):
        backend = get_backend(backend)
        account = backend.activate(request, **kwargs)

        if account or request.user.is_authenticated():
            return redirect(settings.LOGIN_REDIRECT_URL)
        else:
            # ошибка активации
            context = RequestContext(request)
            return self.render_to_response(context)

def register_test_cookie(request, backend, success_url=None, form_class=None,
                         disallowed_url='registration_disallowed',
                         template_name='registration/registration_form.html',
                         extra_context=None):
    """
    Регистрация пользователя.
    Создано основе стандартного представления register из django-registration
    путем добавления в начале проверки включенности cookies в браузере,
    и фокусов с формой в зависимости от статуса регистрирующегося.
    """
    if request.method == 'POST':
        if request.session.test_cookie_worked():
            request.session.delete_test_cookie()
        else:
            return TemplateResponse(request, 'cookies.html')

    request.session.set_test_cookie()
    backend = get_backend(backend)
    if not backend.registration_allowed(request):
        return redirect(disallowed_url)

    if request.method == 'POST':
        status = int(request.POST.get("status", u"0"))
        if status == 1:  # интересующийся гражданин.
            form = RegistrationFormShort(data=request.POST,
                files=request.FILES)
        else:  # представитель организации.
            form = RegistrationFormFull(data=request.POST, files=request.FILES)

        if form.is_valid():
            new_user = backend.register(request, **form.cleaned_data)
            if success_url is None:
                to, args, kwargs = backend.post_registration_redirect(request,
                    new_user)
                return redirect(to, *args, **kwargs)
            else:
                return redirect(success_url)
        else:
            if status == 1:
                form = RegistrationFormFull(data=request.POST,
                                            files=request.FILES)
    else:
        form = RegistrationFormFull()

    if extra_context is None:
        extra_context = {}

    extra_context.update({'required_error':
                              Field.default_error_messages['required']})

    context = {'form': form}
    for key, value in extra_context.items():
        context[key] = callable(value) and value() or value

    return TemplateResponse(request, template_name, context)

def _register_user(request, facebook, profile_callback=None):
    if not facebook.is_authenticated():
        raise ValueError, 'Facebook needs to be authenticated for connect flows'
    
    from registration.forms import RegistrationFormUniqueEmail
    import registration
    new_reg_module = hasattr(registration, 'backends')
    
    if new_reg_module:
        from registration.backends import get_backend
        
    form_class = RegistrationFormUniqueEmail
    facebook_data = facebook.facebook_registration_data()

    data = request.POST.copy()
    for k, v in facebook_data.items():
        if not data.get(k):
            data[k] = v
    
    if request.REQUEST.get('force_registration_hard'):
        data['email'] = data['email'].replace('@', '+%[email protected]' % randint(0, 100000))

    form = form_class(data=data, files=request.FILES,
        initial={'ip': request.META['REMOTE_ADDR']})

    if not form.is_valid():
        error = facebook_exceptions.IncompleteProfileError('Facebook data %s gave error %s' % (facebook_data, form.errors))
        error.form = form
        raise error

    if new_reg_module:
        #support for the newer implementation
        try:
            from django.conf import settings
            backend = get_backend(settings.REGISTRATION_BACKEND)
        except:
            raise ValueError, 'Cannot get django-registration backend from settings.REGISTRATION_BACKEND'
        new_user = backend.register(request, **form.cleaned_data)
    else:
        new_user = form.save(profile_callback=profile_callback)
    
    profile = new_user.get_profile()
    profile.date_of_birth = facebook_data.get('date_of_birth')
    if hasattr(profile, 'raw_data'):
        serialized_fb_data = json.dumps(facebook.facebook_profile_data())
        profile.raw_data = serialized_fb_data
    profile.save()
        
    auth.login(request, new_user)
    
    
    

    return new_user

def login(request):
    error_messages = []

    #grab the redirect URL if set
    redirect = request.GET.get('next') or request.POST.get('redirect', '')

    #Create login and registration forms
    login_form = SigninForm()
    registration_form = CreateAccountForm()
    
    if request.method == 'POST':
        #Existing user is logging in
        if request.POST.has_key('login'):

            login_form = SigninForm(data=request.POST)
            if login_form.is_valid():
                user = auth.authenticate(username=request.POST['user_or_email'], password=request.POST['password'])

                #Log in
                auth.login(request, user)

                #set session timeout
                if request.POST.has_key('remember_me'):
                    request.session.set_expiry(settings.SESSION_TIMEOUT)

                if redirect:
                    return HttpResponseRedirect(redirect)
                else:
                    return HttpResponseRedirect(reverse('frontpage'))

        #New user is registering
        elif request.POST.has_key('register'):

            registration_form = CreateAccountForm(data=request.POST)

            if registration_form.is_valid():
                backend = get_backend(settings.REGISTRATION_BACKEND)             
                new_user = backend.register(request, **registration_form.cleaned_data)

                #sign straight in
                signed_in_user = auth.authenticate(username=request.POST['username'], password=request.POST['password1'])
                auth.login(request, signed_in_user)                

                #redirect
                if redirect:
                    return HttpResponseRedirect(redirect)
                else:
                    return HttpResponseRedirect(reverse('frontpage'))

    return render_to_response('registration/extended_login.html', {'registration_form': registration_form,
                                                                   'login_form': login_form, 
                                                                   'error_messages': error_messages,  
                                                                   'redirect': redirect}, context_instance = RequestContext(request))

 def get(self, request, backend, template_name=None, success_url=None, form_class=None,
          disallowed_url='registration_disallowed', extra_context=None):
     if template_name is not None:
         self.template_name = template_name
     backend = get_backend(backend)
     if not backend.registration_allowed(request):
         return redirect(disallowed_url)
     if form_class is None:
         form_class = backend.get_form_class(request)
     form = form_class()
     context = self._add_extra_context(request, form, extra_context)
     return self.render_to_response(context)

def invited_register(request, backend, invitation_key, success_url=None,
            form_class=RegistrationForm,
            disallowed_url='registration_disallowed',
            post_registration_redirect=None,
            template_name='registration/registration_form.html',
            wrong_template_name='invitations/wrong_invitation_key.html',
            extra_context=None):
    extra_context = extra_context is not None and extra_context.copy() or {}
    if getattr(settings, 'INVITE_MODE', False):
        if invitation_key:
            extra_context.update({'invitation_key': invitation_key})
            # if key is valid
            if is_key_valid(invitation_key):
                key_object = get_key(invitation_key)
                # if email is assigned to an access content_object 
                # but not user - if user is assigned then this invitation has
                # already been accepted
                if ((key_object.content_object and \
                        key_object.content_object.email) and not \
                        key_object.content_object.user):

                    extra_context.update(
                            {'email': key_object.content_object.email})

                    if request.POST:
                        backend = get_backend(backend)
                        form = form_class(data=request.POST, files=request.FILES)
                        if form.is_valid():
                            new_user = backend.register(request, **extra_context)
                            to, args, kwargs = backend.post_registration_redirect(
                                    request,
                                    new_user,
                                    invitation_key=invitation_key)

                            messages.success(request, _("You've been registered and logged in."))                            
                            return redirect(to, *args, **kwargs)
                    else:
                        form = form_class()
                    extra_context.update({'form': form})

                    return render(request, template_name, extra_context)

                #return registration_register(request, backend, success_url,
                #                            form_class, disallowed_url,
                #                            template_name, extra_context)
            extra_context.update({'invalid_key': True})
        else:
            extra_context.update({'no_key': True})
        return render(request, wrong_template_name, extra_context)
    else:
        return registration_register(request, backend, success_url, form_class,
                                     disallowed_url, template_name, extra_context)

    def post(self, request, backend, extra_context=None):
        backend = get_backend(backend)

        form_class = backend.get_register_form_class(request)
        form = form_class(data=request.POST)

        result = {'success': False, 'errors': []}
        if form.is_valid():
            backend.register(request, **form.cleaned_data)
            result = reg_success(request)
        else:
            result['errors'] = form.errors

        return result

def get_registration_backend():
    '''
    Ensures compatability with the new and old version of django registration
    '''
    backend = None
    try:        
        #support for the newer implementation
        from registration.backends import get_backend
        try:
            backend = get_backend(settings.REGISTRATION_BACKEND)
        except:
            raise ValueError, 'Cannot get django-registration backend from settings.REGISTRATION_BACKEND'
    except ImportError, e:
        backend = None

def register(request, backend, success_url=None, form_class=None,
             disallowed_url='registration_disallowed',
             template_name='registration/registration_form.html',
             extra_context=None):


    backend = get_backend(backend)
    if not backend.registration_allowed(request):
        return redirect(disallowed_url)
    if form_class is None:
        form_class = backend.get_form_class(request)

    if request.method == 'POST':
        form = form_class(data=request.POST, files=request.FILES)
        if form.is_valid():
            new_user = backend.register(request, **form.cleaned_data)
            form.save(new_user)

            # need to login the user now also
            user = authenticate(username=form.cleaned_data['username'],
                                password=form.cleaned_data['password1'])
            login(request, user)

            if success_url is None:
                return redirect(settings.REGISTRATION_SUCCESS_URL)
            else:
                return redirect(success_url)

            # MRT CHANGED THE ABOVE
            # save the addtional fields to the user
            '''
            if success_url is None:
                to, args, kwargs = backend.post_registration_redirect(request, new_user)
                return redirect(to, *args, **kwargs)
            else:
                return redirect(success_url)
            '''
    else:
        form = form_class()

    if extra_context is None:
        extra_context = {}
    context = RequestContext(request)
    for key, value in extra_context.items():
        context[key] = callable(value) and value() or value

    return render_to_response(template_name,
                              {'form': form},
                              context_instance=context)

def verify(request, **kwargs):

    backend = 'whwn.register.RegistrationBackend'
    backend = get_backend(backend)
    user = backend.activate(request, **kwargs)

    if user:
        backend.post_activation_redirect(request, user)
        user.backend = 'django.contrib.auth.backends.ModelBackend'
        login(request, user)

            
        return redirect(reverse('inventory_list'))
    else:
        return redirect(reverse('home'))